@sst-community/sst 4.20.0 → 5.0.0-alpha.1

package/platform/types/components/aws/v5/service.d.ts

@@ -0,0 +1,1347 @@
+import { ComponentResourceOptions, type Output } from "@pulumi/pulumi";
+import { V5Args } from "../../parts-component";
+import { type DurationMinutes } from "../../duration";
+import { DevCommand } from "../../experimental/dev-command";
+import type { Input } from "../../input";
+import { Alb as OriginalAlb } from "../alb";
+import { DnsValidatedCertificate } from "../dns-validated-certificate";
+import type { CustomDomainArgs } from "../helpers/custom-domain";
+import { type ContainerArgs, type FargateArgs } from "../helpers/fargate";
+import type { ServiceArgs as OriginalServiceArgs } from "../service";
+import { Alb } from "./alb";
+declare const parts: () => {
+    /**
+     * The Amazon ECS Execution Role.
+     */
+    executionRole: typeof import("@pulumi/aws/iam/role").Role;
+    /**
+     * The Amazon ECS Task Role. In `sst dev` it's the role each container's
+     * command runs as on your machine.
+     */
+    taskRole: typeof import("@pulumi/aws/iam/role").Role;
+    /**
+     * The images built for the service's containers, by the container's name. There's
+     * one for each container that's built from a Dockerfile. It's added once the
+     * container's image settings are known.
+     */
+    image: import("../..").ManyPart<typeof import("@pulumi/docker-build/image").Image>;
+    /**
+     * The CloudWatch log groups of the service's containers, by the container's name.
+     */
+    logGroup: import("../..").ManyPart<typeof import("@pulumi/aws/cloudwatch/logGroup").LogGroup>;
+    /**
+     * The Amazon ECS Task Definition.
+     */
+    taskDefinition: typeof import("@pulumi/aws/ecs/taskDefinition").TaskDefinition;
+    /**
+     * The AWS Security Group of the load balancer. Only created when the service has a
+     * load balancer of its own.
+     */
+    loadBalancerSecurityGroup: import("../..").OptionalPart<typeof import("@pulumi/aws/ec2/securityGroup").SecurityGroup>;
+    /**
+     * The AWS Load Balancer. Only created when `loadBalancer` is set, and not when the
+     * service is attached to an `Alb`.
+     */
+    loadBalancer: import("../..").OptionalPart<typeof import("@pulumi/aws/lb/loadBalancer").LoadBalancer>;
+    /**
+     * The certificate for the load balancer's custom domain, created when
+     * `loadBalancer.domain` is set without a `cert`.
+     */
+    certificate: import("../..").OptionalPart<typeof DnsValidatedCertificate>;
+    /**
+     * The AWS Load Balancer target groups, one for each container port traffic is
+     * forwarded to. Its id is the container's name, the protocol and the port:
+     * `MyServiceHTTP8080`.
+     */
+    target: import("../..").ManyPart<typeof import("@pulumi/aws/lb/targetGroup").TargetGroup>;
+    /**
+     * The AWS Load Balancer listeners, one for each port the load balancer listens on.
+     * Its id is the protocol and the port: `HTTP80`.
+     */
+    listener: import("../..").ManyPart<typeof import("@pulumi/aws/lb/listener").Listener>;
+    /**
+     * The AWS Load Balancer listener rules, one for each rule that has `conditions`.
+     *
+     * For a rule on an `Alb`, its id is the listener and the priority: `HTTPS443P100`.
+     * For a rule on the service's own load balancer, it's the listener and a hash of
+     * the conditions, so a function here is better off reading the rule's args.
+     */
+    listenerRule: import("../..").ManyPart<typeof import("@pulumi/aws/lb/listenerRule").ListenerRule>;
+    /**
+     * The AWS Cloud Map service. Only created when the cluster's VPC has a Cloud Map
+     * namespace, which a VPC you pass in by its ids may not. So it's an output, and
+     * reading it fails when there is no namespace.
+     */
+    cloudmapService: import("../..").DeferredPart<typeof import("@pulumi/aws/servicediscovery/service").Service>;
+    /**
+     * The Amazon ECS Service.
+     */
+    service: typeof import("@pulumi/aws/ecs/service").Service;
+    /**
+     * The AWS Application Auto Scaling target.
+     */
+    autoScalingTarget: typeof import("@pulumi/aws/appautoscaling/target").Target;
+    /**
+     * The AWS Application Auto Scaling policy that tracks CPU utilization. Not created
+     * when `scaling.cpuUtilization` is `false`.
+     */
+    autoScalingCpuPolicy: import("../..").OptionalPart<typeof import("@pulumi/aws/appautoscaling/policy").Policy>;
+    /**
+     * The AWS Application Auto Scaling policy that tracks memory utilization. Not
+     * created when `scaling.memoryUtilization` is `false`.
+     */
+    autoScalingMemoryPolicy: import("../..").OptionalPart<typeof import("@pulumi/aws/appautoscaling/policy").Policy>;
+    /**
+     * The AWS Application Auto Scaling policy that tracks the requests each target
+     * gets. Only created when `scaling.requestCount` is set.
+     */
+    autoScalingRequestCountPolicy: import("../..").OptionalPart<typeof import("@pulumi/aws/appautoscaling/policy").Policy>;
+    /**
+     * What `sst dev` runs in place of each container, by the container's name. It's
+     * added once the container's `dev` settings are known.
+     */
+    devCommand: import("../..").ManyPart<typeof DevCommand>;
+};
+type Port = `${number}/${"http" | "https" | "tcp" | "udp" | "tcp_udp" | "tls"}`;
+type AlbPort = `${number}/${"http" | "https"}`;
+export interface ServiceContainerArgs extends ContainerArgs {
+    /**
+     * Configure the health check for the container. Same as the top-level
+     * [`health`](#health).
+     */
+    health?: OriginalServiceArgs["health"];
+    /**
+     * Configure how this container works in `sst dev`. Same as the top-level
+     * [`dev`](#dev).
+     */
+    dev?: {
+        /**
+         * The command that `sst dev` runs to start this in dev mode. Same as the top-level
+         * [`dev.command`](#dev-command).
+         */
+        command: Input<string>;
+        /**
+         * Configure if you want to automatically start this when `sst dev` starts. Same as the
+         * top-level [`dev.autostart`](#dev-autostart).
+         */
+        autostart?: Input<boolean>;
+        /**
+         * Change the directory from where the `command` is run. Same as the top-level
+         * [`dev.directory`](#dev-directory).
+         */
+        directory?: Input<string>;
+    };
+}
+export interface ServiceDomainArgs extends CustomDomainArgs {
+    /**
+     * The custom domain you want to use.
+     *
+     * @example
+     * ```js
+     * {
+     *   domain: {
+     *     name: "example.com"
+     *   }
+     * }
+     * ```
+     *
+     * Can also include subdomains based on the current stage.
+     *
+     * ```js
+     * {
+     *   domain: {
+     *     name: `${$app.stage}.example.com`
+     *   }
+     * }
+     * ```
+     *
+     * Wildcard domains are supported.
+     *
+     * ```js
+     * {
+     *   domain: {
+     *     name: "*.example.com"
+     *   }
+     * }
+     * ```
+     */
+    name: Input<string>;
+    /**
+     * Alias domains that should be used. A plain list: each alias gets DNS records of
+     * its own.
+     *
+     * @example
+     * ```js {4}
+     * {
+     *   domain: {
+     *     name: "app1.example.com",
+     *     aliases: ["app2.example.com"]
+     *   }
+     * }
+     * ```
+     */
+    aliases?: string[];
+}
+export interface ServiceRuleArgs {
+    /**
+     * The port and protocol the service listens on. Uses the format `{port}/{protocol}`.
+     *
+     * @example
+     * ```js
+     * {
+     *   listen: "80/http"
+     * }
+     * ```
+     */
+    listen: Port;
+    /**
+     * The port and protocol of the container the service forwards the traffic to. Uses the
+     * format `{port}/{protocol}`.
+     *
+     * @example
+     * ```js
+     * {
+     *   forward: "80/http"
+     * }
+     * ```
+     * @default The same port and protocol as `listen`.
+     */
+    forward?: Port;
+    /**
+     * The name of the container to forward the traffic to. This maps to the `name` defined in
+     * `containers`.
+     *
+     * You only need this if there's more than one container. If there's only one container, the
+     * traffic is automatically forwarded there.
+     */
+    container?: string;
+    /**
+     * The port and protocol to redirect the traffic to. Uses the format `{port}/{protocol}`.
+     *
+     * @example
+     * ```js
+     * {
+     *   redirect: "80/http"
+     * }
+     * ```
+     */
+    redirect?: Port;
+    /**
+     * The conditions a request has to match for the rule to apply. Only applicable to
+     * `http` and `https` protocols.
+     *
+     * These are plain values all the way down. The listener rule is named after them.
+     */
+    conditions?: {
+        /**
+         * Configure path-based routing. Only requests matching the path are forwarded to
+         * the container.
+         *
+         * ```js
+         * {
+         *   path: "/api/*"
+         * }
+         * ```
+         *
+         * The path pattern is case-sensitive, supports wildcards, and can be up to 128
+         * characters.
+         * - `*` matches 0 or more characters. For example, `/api/*` matches `/api/` or
+         *   `/api/orders`.
+         * - `?` matches exactly 1 character. For example, `/api/?.png` matches `/api/a.png`.
+         *
+         * @default Requests to all paths are forwarded.
+         */
+        path?: string;
+        /**
+         * Configure query string based routing. Only requests matching one of the query
+         * string conditions are forwarded to the container.
+         *
+         * Takes a list of `key`, the name of the query string parameter, and `value` pairs.
+         * Where `value` is the value of the query string parameter. But it can be a pattern as well.
+         *
+         * If multiple `key` and `value` pairs are provided, it'll match requests with **any** of the
+         * query string parameters.
+         *
+         * @default Query string is not checked when forwarding requests.
+         *
+         * @example
+         *
+         * For example, to match requests with query string `version=v1`.
+         *
+         * ```js
+         * {
+         *   query: [
+         *     { key: "version", value: "v1" }
+         *   ]
+         * }
+         * ```
+         *
+         * Or match requests with query string matching `env=test*`.
+         *
+         * ```js
+         * {
+         *   query: [
+         *     { key: "env", value: "test*" }
+         *   ]
+         * }
+         * ```
+         *
+         * Match requests with query string `version=v1` **or** `env=test*`.
+         *
+         * ```js
+         * {
+         *   query: [
+         *     { key: "version", value: "v1" },
+         *     { key: "env", value: "test*" }
+         *   ]
+         * }
+         * ```
+         *
+         * Match requests with any query string key with value `example`.
+         *
+         * ```js
+         * {
+         *   query: [
+         *     { value: "example" }
+         *   ]
+         * }
+         * ```
+         */
+        query?: {
+            /**
+             * The name of the query string parameter.
+             */
+            key?: string;
+            /**
+             * The value of the query string parameter.
+             *
+             * If no `key` is provided, it'll match any request where a query string parameter with
+             * the given value exists.
+             */
+            value: string;
+        }[];
+        /**
+         * Configure header based routing. Only requests matching the header
+         * name and values are forwarded to the container.
+         *
+         * Both the header name and values are case insensitive.
+         *
+         * @default Header is not checked when forwarding requests.
+         *
+         * @example
+         *
+         * For example, if you specify `X-Custom-Header` as the name and `Value1`
+         * as a value, it will match requests with the header
+         * `x-custom-header: value1` as well.
+         *
+         * ```js
+         * {
+         *   header: {
+         *     name: "X-Custom-Header",
+         *     values: ["Value1", "Value2", "Prefix*"]
+         *   }
+         * }
+         * ```
+         */
+        header?: {
+            /**
+             * The name of the HTTP header field to check. This is case-insensitive.
+             */
+            name: string;
+            /**
+             * The values to match against the header value. The rule matches if the
+             * request header matches any of these values. Values are case-insensitive
+             * and support wildcards (`*` and `?`) for pattern matching.
+             */
+            values: string[];
+        };
+    };
+}
+export interface ServiceHealthCheckArgs {
+    /**
+     * The URL path to ping on the service for health checks. Only applicable to
+     * `http` and `https` protocols.
+     * @default `"/"`
+     */
+    path?: Input<string>;
+    /**
+     * The time period between each health check request. Must be between `5 seconds`
+     * and `300 seconds`.
+     * @default `"30 seconds"`
+     */
+    interval?: Input<DurationMinutes>;
+    /**
+     * The timeout for each health check request. If no response is received within this
+     * time, it is considered failed. Must be between `2 seconds` and `120 seconds`.
+     * @default `"5 seconds"`
+     */
+    timeout?: Input<DurationMinutes>;
+    /**
+     * The number of consecutive successful health check requests required to consider the
+     * target healthy. Must be between 2 and 10.
+     * @default `5`
+     */
+    healthyThreshold?: Input<number>;
+    /**
+     * The number of consecutive failed health check requests required to consider the
+     * target unhealthy. Must be between 2 and 10.
+     * @default `2`
+     */
+    unhealthyThreshold?: Input<number>;
+    /**
+     * One or more HTTP response codes the health check treats as successful. Only
+     * applicable to `http` and `https` protocols.
+     *
+     * @default `"200"`
+     * @example
+     * ```js
+     * {
+     *   successCodes: "200-299"
+     * }
+     * ```
+     */
+    successCodes?: Input<string>;
+}
+export interface ServiceLoadBalancerArgs {
+    /**
+     * Configure if the load balancer should be public or private.
+     *
+     * When set to `false`, the load balancer endpoint will only be accessible within the
+     * VPC.
+     *
+     * @default `true`
+     */
+    public?: Input<boolean>;
+    /**
+     * Set a custom domain for your load balancer endpoint.
+     *
+     * Automatically manages domains hosted on AWS Route 53, Cloudflare, and Vercel. For other
+     * providers, you'll need to pass in a `cert` that validates domain ownership and add the
+     * DNS records.
+     *
+     * :::tip
+     * Built-in support for AWS Route 53, Cloudflare, and Vercel. And manual setup for other
+     * providers.
+     * :::
+     *
+     * @example
+     *
+     * By default this assumes the domain is hosted on Route 53.
+     *
+     * ```js
+     * {
+     *   domain: "example.com"
+     * }
+     * ```
+     *
+     * For domains hosted on Cloudflare.
+     *
+     * ```js
+     * {
+     *   domain: {
+     *     name: "example.com",
+     *     dns: sst.cloudflare.dns()
+     *   }
+     * }
+     * ```
+     */
+    domain?: string | ServiceDomainArgs;
+    /**
+     * Configure the mapping for the ports the load balancer listens to, forwards, or redirects to
+     * the service.
+     * This supports two types of protocols:
+     *
+     * 1. Application Layer Protocols: `http` and `https`. This'll create an [Application Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/introduction.html).
+     * 2. Network Layer Protocols: `tcp`, `udp`, `tcp_udp`, and `tls`. This'll create a [Network Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/introduction.html).
+     *
+     * :::note
+     * If you want to listen on `https` or `tls`, you need to specify a custom
+     * `loadBalancer.domain`.
+     * :::
+     *
+     * You **can not configure** both application and network layer protocols for the same
+     * service.
+     *
+     * The list and each rule are plain values. They decide which listeners, target groups
+     * and listener rules are created.
+     *
+     * @example
+     * Here we are listening on port `80` and forwarding it to the service on port `8080`.
+     * ```js
+     * {
+     *   rules: [
+     *     { listen: "80/http", forward: "8080/http" }
+     *   ]
+     * }
+     * ```
+     *
+     * The `forward` port and protocol defaults to the `listen` port and protocol. So in this
+     * case both are `80/http`.
+     *
+     * ```js
+     * {
+     *   rules: [
+     *     { listen: "80/http" }
+     *   ]
+     * }
+     * ```
+     *
+     * If multiple containers are configured via the `containers` argument, you need to
+     * specify which container the traffic should be forwarded to.
+     *
+     * ```js
+     * {
+     *   rules: [
+     *     { listen: "80/http", container: "app" },
+     *     { listen: "8000/http", container: "admin" }
+     *   ]
+     * }
+     * ```
+     *
+     * You can also route the same port to multiple containers via path-based routing.
+     *
+     * ```js
+     * {
+     *   rules: [
+     *     {
+     *       listen: "80/http",
+     *       container: "app",
+     *       conditions: { path: "/api/*" }
+     *     },
+     *     {
+     *       listen: "80/http",
+     *       container: "admin",
+     *       conditions: { path: "/admin/*" }
+     *     }
+     *   ]
+     * }
+     * ```
+     *
+     * Additionally, you can redirect traffic from one port to another. This is
+     * commonly used to redirect http to https.
+     *
+     * ```js
+     * {
+     *   rules: [
+     *     { listen: "80/http", redirect: "443/https" },
+     *     { listen: "443/https", forward: "80/http" }
+     *   ]
+     * }
+     * ```
+     */
+    rules: ServiceRuleArgs[];
+    /**
+     * Configure the health check that the load balancer runs on your containers.
+     *
+     * :::tip
+     * This health check is different from the [`health`](#health) check.
+     * :::
+     *
+     * This health check is run by the load balancer. While, `health` is run by ECS. This
+     * cannot be disabled if you are using a load balancer. While the other is off by default.
+     *
+     * Since this cannot be disabled, here are some tips on how to debug an unhealthy
+     * health check.
+     *
+     * <details>
+     * <summary>How to debug a load balancer health check</summary>
+     *
+     * If you notice a `Unhealthy: Health checks failed` error, it's because the health
+     * check has failed. When it fails, the load balancer will terminate the containers,
+     * causing any requests to fail.
+     *
+     * Here's how to debug it:
+     *
+     * 1. Verify the health check path.
+     *
+     *    By default, the load balancer checks the `/` path. Ensure it's accessible in your
+     *    containers. If your application runs on a different path, then update the path in
+     *    the health check config accordingly.
+     *
+     * 2. Confirm the containers are operational.
+     *
+     *    Navigate to **ECS console** > select the **cluster** > go to the **Tasks tab** >
+     *    choose **Any desired status** under the **Filter desired status** dropdown > select
+     *    a task and check for errors under the **Logs tab**. If it has error that means that
+     *    the container failed to start.
+     *
+     * 3. If the container was terminated by the load balancer while still starting up, try
+     *    increasing the health check interval and timeout.
+     * </details>
+     *
+     * For `http` and `https` the default is:
+     *
+     * ```js
+     * {
+     *   path: "/",
+     *   healthyThreshold: 5,
+     *   successCodes: "200",
+     *   timeout: "5 seconds",
+     *   unhealthyThreshold: 2,
+     *   interval: "30 seconds"
+     * }
+     * ```
+     *
+     * For `tcp` and `udp` the default is:
+     *
+     * ```js
+     * {
+     *   healthyThreshold: 5,
+     *   timeout: "6 seconds",
+     *   unhealthyThreshold: 2,
+     *   interval: "30 seconds"
+     * }
+     * ```
+     *
+     * @example
+     *
+     * To configure the health check, we use the _port/protocol_ format. Here we are
+     * configuring a health check that pings the `/health` path on port `8080`
+     * every 10 seconds.
+     *
+     * ```js
+     * {
+     *   rules: [
+     *     { listen: "80/http", forward: "8080/http" }
+     *   ],
+     *   health: {
+     *     "8080/http": {
+     *       path: "/health",
+     *       interval: "10 seconds"
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    health?: Record<Port, Input<ServiceHealthCheckArgs>>;
+}
+export interface ServiceAlbRuleArgs {
+    /**
+     * The port and protocol to listen on, in `{port}/{protocol}` format. Must match a listener on the ALB.
+     *
+     * @example
+     * ```js
+     * {
+     *   listen: "443/https"
+     * }
+     * ```
+     */
+    listen: AlbPort;
+    /**
+     * The container port and protocol to forward traffic to. Uses the format `{port}/{protocol}`.
+     *
+     * The protocol must match what the container actually speaks. Using `"3000/https"` when
+     * the container speaks HTTP will cause health check failures.
+     *
+     * @example
+     * ```js
+     * {
+     *   forward: "8080/http"
+     * }
+     * ```
+     */
+    forward: AlbPort;
+    /**
+     * The name of the container to forward the traffic to. Required when multiple containers
+     * are configured.
+     */
+    container?: string;
+    /**
+     * The conditions for the listener rule. At least one condition (path, query, or header)
+     * must be specified. The ALB owns the default action, and a service only adds conditional
+     * rules.
+     *
+     * @example
+     * ```js
+     * {
+     *   conditions: {
+     *     path: "/api/*"
+     *   }
+     * }
+     * ```
+     */
+    conditions: {
+        /**
+         * Path pattern to match. Supports wildcards (`*` and `?`).
+         */
+        path?: Input<string>;
+        /**
+         * Query string conditions.
+         */
+        query?: Input<Input<{
+            key?: Input<string>;
+            value: Input<string>;
+        }>[]>;
+        /**
+         * HTTP header condition.
+         */
+        header?: Input<{
+            name: Input<string>;
+            values: Input<Input<string>>[];
+        }>;
+    };
+    /**
+     * Explicit priority for the listener rule (1–50000).
+     * Must be unique per listener across ALL services sharing the ALB.
+     * Use non-overlapping ranges per service (e.g., Service A: 100-199, Service B: 200-299).
+     *
+     * @example
+     * ```js
+     * {
+     *   priority: 100
+     * }
+     * ```
+     */
+    priority: number;
+}
+export interface ServiceAlbArgs {
+    /**
+     * The `Alb` instance to attach this service to. When provided, the service creates
+     * target groups and listener rules on the shared ALB instead of creating its own
+     * load balancer.
+     *
+     * ECS tasks use the VPC's default security group, which allows all traffic within the
+     * VPC CIDR. For tighter security, add an explicit security group ingress rule from the
+     * ALB's security group using `transform`.
+     *
+     * @example
+     * ```js
+     * {
+     *   loadBalancer: {
+     *     instance: alb,
+     *     rules: [
+     *       { listen: "443/https", forward: "8080/http", conditions: { path: "/api/*" }, priority: 100 }
+     *     ]
+     *   }
+     * }
+     * ```
+     */
+    instance: OriginalAlb | Alb;
+    /**
+     * The rules for routing traffic from the ALB to this service's containers.
+     * Each rule must have explicit conditions and priority.
+     */
+    rules: ServiceAlbRuleArgs[];
+    /**
+     * Configure health checks for the target groups, keyed by the `{port}/{protocol}` the
+     * traffic is forwarded to.
+     */
+    health?: Record<AlbPort, Input<ServiceHealthCheckArgs>>;
+}
+export interface ServiceArgs extends V5Args<Omit<OriginalServiceArgs, "cluster" | "containers" | "volumes" | "taskRole" | "executionRole" | "public" | "loadBalancer" | "scaling">, typeof parts>, FargateArgs {
+    /**
+     * Configure a load balancer to route traffic to the containers.
+     *
+     * While you can expose a service through API Gateway, it's better to use a load balancer
+     * for most traditional web applications. It is more expensive to start but at higher
+     * levels of traffic it ends up being more cost effective.
+     *
+     * Also, if you need to listen on network layer protocols like `tcp` or `udp`, you have to
+     * expose it through a load balancer.
+     *
+     * By default, the endpoint is an auto-generated load balancer URL. You can also add a
+     * custom domain for the endpoint.
+     *
+     * This has to be a plain value, and so do its `domain` and `rules`. They decide which
+     * resources are created.
+     *
+     * @default Load balancer is not created
+     * @example
+     *
+     * ```js
+     * {
+     *   loadBalancer: {
+     *     domain: "example.com",
+     *     rules: [
+     *       { listen: "80/http", redirect: "443/https" },
+     *       { listen: "443/https", forward: "80/http" }
+     *     ]
+     *   }
+     * }
+     * ```
+     *
+     * To share a load balancer between services, pass in an `Alb`. The service then adds
+     * its target groups and listener rules to it.
+     *
+     * ```js
+     * {
+     *   loadBalancer: {
+     *     instance: alb,
+     *     rules: [
+     *       { listen: "443/https", forward: "8080/http", conditions: { path: "/api/*" }, priority: 100 }
+     *     ]
+     *   }
+     * }
+     * ```
+     */
+    loadBalancer?: ServiceLoadBalancerArgs | ServiceAlbArgs;
+    /**
+     * Configure the service to automatically scale up or down based on the CPU or memory
+     * utilization of a container. By default, scaling is disabled and the service will run
+     * in a single container.
+     *
+     * This has to be a plain value, and so do `cpuUtilization`, `memoryUtilization` and
+     * `requestCount`. They decide which scaling policies are created.
+     *
+     * @default `{ min: 1, max: 1 }`
+     *
+     * @example
+     * ```js
+     * {
+     *   scaling: {
+     *     min: 4,
+     *     max: 16,
+     *     cpuUtilization: 50,
+     *     memoryUtilization: 50
+     *   }
+     * }
+     * ```
+     */
+    scaling?: {
+        /**
+         * The minimum number of containers to scale down to.
+         * @default `1`
+         * @example
+         * ```js
+         * {
+         *   scaling: {
+         *     min: 4
+         *   }
+         * }
+         * ```
+         */
+        min?: Input<number>;
+        /**
+         * The maximum number of containers to scale up to.
+         * @default `1`
+         * @example
+         * ```js
+         * {
+         *   scaling: {
+         *     max: 16
+         *   }
+         * }
+         * ```
+         */
+        max?: Input<number>;
+        /**
+         * The target CPU utilization percentage to scale up or down. It'll scale up
+         * when the CPU utilization is above the target and scale down when it's below the target.
+         * @default `70`
+         * @example
+         * ```js
+         * {
+         *   scaling: {
+         *     cpuUtilization: 50
+         *   }
+         * }
+         * ```
+         */
+        cpuUtilization?: false | number;
+        /**
+         * The target memory utilization percentage to scale up or down. It'll scale up
+         * when the memory utilization is above the target and scale down when it's below the target.
+         * @default `70`
+         * @example
+         * ```js
+         * {
+         *   scaling: {
+         *     memoryUtilization: 50
+         *   }
+         * }
+         * ```
+         */
+        memoryUtilization?: false | number;
+        /**
+         * The target request count to scale up or down. It'll scale up when the request count is
+         * above the target and scale down when it's below the target.
+         * @default `false`
+         * @example
+         * ```js
+         * {
+         *   scaling: {
+         *     requestCount: 1500
+         *   }
+         * }
+         * ```
+         */
+        requestCount?: false | number;
+        /**
+         * The amount of time, in seconds, after a scale-in activity completes before another scale-in activity can start.
+         * This prevents the auto scaler from removing too many tasks too quickly.
+         * @example
+         * ```js
+         * {
+         *   scaling: {
+         *     scaleInCooldown: "60 seconds"
+         *   }
+         * }
+         * ```
+         */
+        scaleInCooldown?: Input<DurationMinutes>;
+        /**
+         * The amount of time, in seconds, after a scale-out activity completes before another scale-out activity can start.
+         * This prevents the auto scaler from adding too many tasks too quickly.
+         * @example
+         * ```js
+         * {
+         *   scaling: {
+         *     scaleOutCooldown: "60 seconds"
+         *   }
+         * }
+         * ```
+         */
+        scaleOutCooldown?: Input<DurationMinutes>;
+    };
+    /**
+     * The containers to run in the service.
+     *
+     * :::tip
+     * You can optionally run multiple containers in a service.
+     * :::
+     *
+     * By default this starts a single container. To add multiple containers in the service, pass
+     * in an array of containers args.
+     *
+     * ```ts
+     * {
+     *   containers: [
+     *     {
+     *       name: "app",
+     *       image: "nginxdemos/hello:plain-text"
+     *     },
+     *     {
+     *       name: "admin",
+     *       image: {
+     *         context: "./admin",
+     *         dockerfile: "Dockerfile"
+     *       }
+     *     }
+     *   ]
+     * }
+     * ```
+     *
+     * If you specify `containers`, you cannot list the above args at the top-level. For example,
+     * you **cannot** pass in `image` at the top level.
+     *
+     * ```diff lang="ts"
+     * {
+     * -  image: "nginxdemos/hello:plain-text",
+     *   containers: [
+     *     {
+     *       name: "app",
+     *       image: "nginxdemos/hello:plain-text"
+     *     },
+     *     {
+     *       name: "admin",
+     *       image: "nginxdemos/hello:plain-text"
+     *     }
+     *   ]
+     * }
+     * ```
+     *
+     * You will need to pass in `image` as a part of the `containers`.
+     *
+     * The list, each container and its `name` have to be plain values. What's inside a
+     * container can be an output.
+     */
+    containers?: ServiceContainerArgs[];
+}
+declare const Service_base: import("../..").ComponentClass<{
+    /**
+     * The Amazon ECS Execution Role.
+     */
+    executionRole: typeof import("@pulumi/aws/iam/role").Role;
+    /**
+     * The Amazon ECS Task Role. In `sst dev` it's the role each container's
+     * command runs as on your machine.
+     */
+    taskRole: typeof import("@pulumi/aws/iam/role").Role;
+    /**
+     * The images built for the service's containers, by the container's name. There's
+     * one for each container that's built from a Dockerfile. It's added once the
+     * container's image settings are known.
+     */
+    image: import("../..").ManyPart<typeof import("@pulumi/docker-build/image").Image>;
+    /**
+     * The CloudWatch log groups of the service's containers, by the container's name.
+     */
+    logGroup: import("../..").ManyPart<typeof import("@pulumi/aws/cloudwatch/logGroup").LogGroup>;
+    /**
+     * The Amazon ECS Task Definition.
+     */
+    taskDefinition: typeof import("@pulumi/aws/ecs/taskDefinition").TaskDefinition;
+    /**
+     * The AWS Security Group of the load balancer. Only created when the service has a
+     * load balancer of its own.
+     */
+    loadBalancerSecurityGroup: import("../..").OptionalPart<typeof import("@pulumi/aws/ec2/securityGroup").SecurityGroup>;
+    /**
+     * The AWS Load Balancer. Only created when `loadBalancer` is set, and not when the
+     * service is attached to an `Alb`.
+     */
+    loadBalancer: import("../..").OptionalPart<typeof import("@pulumi/aws/lb/loadBalancer").LoadBalancer>;
+    /**
+     * The certificate for the load balancer's custom domain, created when
+     * `loadBalancer.domain` is set without a `cert`.
+     */
+    certificate: import("../..").OptionalPart<typeof DnsValidatedCertificate>;
+    /**
+     * The AWS Load Balancer target groups, one for each container port traffic is
+     * forwarded to. Its id is the container's name, the protocol and the port:
+     * `MyServiceHTTP8080`.
+     */
+    target: import("../..").ManyPart<typeof import("@pulumi/aws/lb/targetGroup").TargetGroup>;
+    /**
+     * The AWS Load Balancer listeners, one for each port the load balancer listens on.
+     * Its id is the protocol and the port: `HTTP80`.
+     */
+    listener: import("../..").ManyPart<typeof import("@pulumi/aws/lb/listener").Listener>;
+    /**
+     * The AWS Load Balancer listener rules, one for each rule that has `conditions`.
+     *
+     * For a rule on an `Alb`, its id is the listener and the priority: `HTTPS443P100`.
+     * For a rule on the service's own load balancer, it's the listener and a hash of
+     * the conditions, so a function here is better off reading the rule's args.
+     */
+    listenerRule: import("../..").ManyPart<typeof import("@pulumi/aws/lb/listenerRule").ListenerRule>;
+    /**
+     * The AWS Cloud Map service. Only created when the cluster's VPC has a Cloud Map
+     * namespace, which a VPC you pass in by its ids may not. So it's an output, and
+     * reading it fails when there is no namespace.
+     */
+    cloudmapService: import("../..").DeferredPart<typeof import("@pulumi/aws/servicediscovery/service").Service>;
+    /**
+     * The Amazon ECS Service.
+     */
+    service: typeof import("@pulumi/aws/ecs/service").Service;
+    /**
+     * The AWS Application Auto Scaling target.
+     */
+    autoScalingTarget: typeof import("@pulumi/aws/appautoscaling/target").Target;
+    /**
+     * The AWS Application Auto Scaling policy that tracks CPU utilization. Not created
+     * when `scaling.cpuUtilization` is `false`.
+     */
+    autoScalingCpuPolicy: import("../..").OptionalPart<typeof import("@pulumi/aws/appautoscaling/policy").Policy>;
+    /**
+     * The AWS Application Auto Scaling policy that tracks memory utilization. Not
+     * created when `scaling.memoryUtilization` is `false`.
+     */
+    autoScalingMemoryPolicy: import("../..").OptionalPart<typeof import("@pulumi/aws/appautoscaling/policy").Policy>;
+    /**
+     * The AWS Application Auto Scaling policy that tracks the requests each target
+     * gets. Only created when `scaling.requestCount` is set.
+     */
+    autoScalingRequestCountPolicy: import("../..").OptionalPart<typeof import("@pulumi/aws/appautoscaling/policy").Policy>;
+    /**
+     * What `sst dev` runs in place of each container, by the container's name. It's
+     * added once the container's `dev` settings are known.
+     */
+    devCommand: import("../..").ManyPart<typeof DevCommand>;
+}>;
+/**
+ * The `Service` component lets you create containers that are always running, like web or
+ * application servers. It uses [Amazon ECS](https://aws.amazon.com/ecs/) on [AWS Fargate](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/AWS_Fargate.html).
+ *
+ * It takes the same args as [`sst.aws.Service`](/docs/component/aws/service) and creates the
+ * same resources. It's built from parts, so every resource it creates can be transformed,
+ * is available in `nodes`, and can be swapped for one you already have.
+ *
+ * @example
+ *
+ * #### Create a Service
+ *
+ * Services are run inside an ECS Cluster. If you haven't already, create one.
+ *
+ * ```ts title="sst.config.ts"
+ * const vpc = new sst.aws.Vpc("MyVpc");
+ * const cluster = new sst.aws.v5.Cluster("MyCluster", { vpc });
+ * ```
+ *
+ * Add the service to it.
+ *
+ * ```ts title="sst.config.ts"
+ * const service = new sst.aws.v5.Service("MyService", { cluster });
+ * ```
+ *
+ * #### Configure the container image
+ *
+ * By default, the service will look for a Dockerfile in the root directory. Optionally
+ * configure the image context and dockerfile.
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.aws.v5.Service("MyService", {
+ *   cluster,
+ *   image: {
+ *     context: "./app",
+ *     dockerfile: "Dockerfile"
+ *   }
+ * });
+ * ```
+ *
+ * To add multiple containers in the service, pass in an array of containers args.
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.aws.v5.Service("MyService", {
+ *   cluster,
+ *   containers: [
+ *     {
+ *       name: "app",
+ *       image: "nginxdemos/hello:plain-text"
+ *     },
+ *     {
+ *       name: "admin",
+ *       image: {
+ *         context: "./admin",
+ *         dockerfile: "Dockerfile"
+ *       }
+ *     }
+ *   ]
+ * });
+ * ```
+ *
+ * This is useful for running sidecar containers.
+ *
+ * #### Enable auto-scaling
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.aws.v5.Service("MyService", {
+ *   cluster,
+ *   scaling: {
+ *     min: 4,
+ *     max: 16,
+ *     cpuUtilization: 50,
+ *     memoryUtilization: 50
+ *   }
+ * });
+ * ```
+ *
+ * #### Expose through API Gateway
+ *
+ * You can give your service a public URL by exposing it through API Gateway HTTP API. You can
+ * also optionally give it a custom domain.
+ *
+ * ```ts title="sst.config.ts"
+ * const service = new sst.aws.v5.Service("MyService", {
+ *   cluster,
+ *   serviceRegistry: {
+ *     port: 80
+ *   }
+ * });
+ *
+ * const api = new sst.aws.v5.ApiGatewayV2("MyApi", {
+ *   vpc,
+ *   domain: "example.com"
+ * });
+ * api.routePrivate("$default", service.nodes.cloudmapService.arn);
+ * ```
+ *
+ * #### Add a load balancer
+ *
+ * You can also expose your service by adding a load balancer to it and optionally
+ * adding a custom domain.
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.aws.v5.Service("MyService", {
+ *   cluster,
+ *   loadBalancer: {
+ *     domain: "example.com",
+ *     rules: [
+ *       { listen: "80/http" },
+ *       { listen: "443/https", forward: "80/http" }
+ *     ]
+ *   }
+ * });
+ * ```
+ *
+ * #### Link resources
+ *
+ * [Link resources](/docs/linking/) to your service. This will grant permissions
+ * to the resources and allow you to access it in your app.
+ *
+ * ```ts {5} title="sst.config.ts"
+ * const bucket = new sst.aws.v5.Bucket("MyBucket");
+ *
+ * new sst.aws.v5.Service("MyService", {
+ *   cluster,
+ *   link: [bucket]
+ * });
+ * ```
+ *
+ * You can use the [SDK](/docs/reference/sdk/) to access the linked resources in your service.
+ *
+ * ```ts title="app.ts"
+ * import { Resource } from "sst";
+ *
+ * console.log(Resource.MyBucket.name);
+ * ```
+ *
+ * #### Service discovery
+ *
+ * This component automatically creates a Cloud Map service host name for the
+ * service. So anything in the same VPC can access it using the service's host name.
+ *
+ * For example, if you link the service to a Lambda function that's in the same VPC.
+ *
+ * ```ts title="sst.config.ts" {2,4}
+ * new sst.aws.v5.Function("MyFunction", {
+ *   vpc,
+ *   url: true,
+ *   link: [service],
+ *   handler: "lambda.handler"
+ * });
+ * ```
+ *
+ * You can access the service by its host name using the [SDK](/docs/reference/sdk/).
+ *
+ * ```ts title="lambda.ts"
+ * import { Resource } from "sst";
+ *
+ * await fetch(`http://${Resource.MyService.service}`);
+ * ```
+ *
+ * [Check out an example](/docs/examples/#aws-cluster-service-discovery).
+ *
+ * #### Use roles you already have
+ *
+ * Pass the role, or its name.
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.aws.v5.Service("MyService", {
+ *   cluster,
+ *   existing: {
+ *     taskRole: "my-task-role",
+ *     executionRole: "my-execution-role"
+ *   }
+ * });
+ * ```
+ *
+ * #### Switch from `sst.aws.Service`
+ *
+ * Change `sst.aws.Service` to `sst.aws.v5.Service` and keep the name. The ECS service, its
+ * task definition, roles, log groups and images, the load balancer with its listeners and
+ * target groups, the Cloud Map service and the scaling policies are kept.
+ *
+ * ```ts title="sst.config.ts" del={1} ins={2}
+ * const service = new sst.aws.Service("MyService", { cluster });
+ * const service = new sst.aws.v5.Service("MyService", { cluster });
+ * ```
+ *
+ * A few things are written differently:
+ *
+ * - `taskRole: "my-task-role"` becomes `existing: { taskRole: "my-task-role" }`, and the
+ *   same for `executionRole`.
+ * - `public`, which `sst.aws.Service` deprecated, is `loadBalancer`. Its `ports` are
+ *   `rules`, and a rule's `path` is `conditions.path`.
+ * - `loadBalancer`, its `domain`, its `rules` and each rule are plain values, not outputs.
+ *   So are `scaling` and its `cpuUtilization`, `memoryUtilization` and `requestCount`, and
+ *   the list of `containers`, each container and its `name`. They decide which resources
+ *   are created.
+ * - `nodes.service` and `nodes.taskDefinition` are the resources, not outputs of them.
+ *   `nodes` also has the log groups, images, listeners, target groups and scaling
+ *   policies.
+ * - `nodes.loadBalancer` is the load balancer the service creates. For a service that's
+ *   attached to an `Alb`, read it from the `Alb`.
+ * - A `transform` function for `service`, `taskDefinition`, `logGroup`, `target` or
+ *   `listener` is given outputs where `sst.aws.Service` gave it plain values. For a part
+ *   there are several of, it's also given which one.
+ * - `transform.listenerRule` applies to the rules of the service's own load balancer too,
+ *   not only to the rules on an `Alb`.
+ * - If you set part of the ECS service's `networkConfiguration` or
+ *   `deploymentCircuitBreaker`, of a target group's `healthCheck`, or of the task
+ *   definition's `runtimePlatform`, with an object in `transform`, the rest of it is kept.
+ *
+ * One thing changes on the first deploy, and nothing in AWS: what `sst dev` runs for each
+ * container is kept inside the service now, so it's listed as removed and created again.
+ *
+ * ---
+ *
+ * ### Cost
+ *
+ * By default, this uses a _Linux/X86_ _Fargate_ container with 0.25 vCPUs at $0.04048 per
+ * vCPU per hour and 0.5 GB of memory at $0.004445 per GB per hour. It includes 20GB of
+ * _Ephemeral Storage_ for free with additional storage at $0.000111 per GB per hour. Each
+ * container also gets a public IPv4 address at $0.005 per hour.
+ *
+ * It works out to $0.04048 x 0.25 x 24 x 30 + $0.004445 x 0.5 x 24 x 30 + $0.005
+ * x 24 x 30 or **$12 per month**.
+ *
+ * If you are using all Fargate Spot instances with `capacity: "spot"`, it's $0.01218784 x 0.25
+ * x 24 x 30 + $0.00133831 x 0.5 x 24 x 30 + $0.005 x 24 x 30 or **$6 per month**
+ *
+ * Adjust this for the `cpu`, `memory` and `storage` you are using. And
+ * check the prices for _Linux/ARM_ if you are using `arm64` as your `architecture`.
+ *
+ * The above are rough estimates for _us-east-1_, check out the
+ * [Fargate pricing](https://aws.amazon.com/fargate/pricing/) and the
+ * [Public IPv4 Address pricing](https://aws.amazon.com/vpc/pricing/) for more details.
+ *
+ * #### Scaling
+ *
+ * By default, `scaling` is disabled. If enabled, adjust the above for the number of containers.
+ *
+ * #### API Gateway
+ *
+ * If you expose your service through API Gateway, you'll need to add the cost of
+ * [API Gateway HTTP API](https://aws.amazon.com/api-gateway/pricing/#HTTP_APIs) as well.
+ * For services that don't get a lot of traffic, this ends up being a lot cheaper since API
+ * Gateway is pay per request.
+ *
+ * Learn more about using
+ * [Cluster with API Gateway](/docs/examples/#aws-cluster-with-api-gateway).
+ *
+ * #### Application Load Balancer
+ *
+ * If you add `loadBalancer` _HTTP_ or _HTTPS_ `rules`, an ALB is created at $0.0225 per hour,
+ * $0.008 per LCU-hour, and $0.005 per hour if HTTPS with a custom domain is used. Where LCU
+ * is a measure of how much traffic is processed.
+ *
+ * That works out to $0.0225 x 24 x 30 or **$16 per month**. Add $0.005 x 24 x 30 or **$4 per
+ * month** for HTTPS. Also add the LCU-hour used.
+ *
+ * The above are rough estimates for _us-east-1_, check out the
+ * [Application Load Balancer pricing](https://aws.amazon.com/elasticloadbalancing/pricing/)
+ * for more details.
+ *
+ * #### Network Load Balancer
+ *
+ * If you add `loadBalancer` _TCP_, _UDP_, or _TLS_ `rules`, an NLB is created at $0.0225 per hour and
+ * $0.006 per NLCU-hour. Where NCLU is a measure of how much traffic is processed.
+ *
+ * That works out to $0.0225 x 24 x 30 or **$16 per month**. Also add the NLCU-hour used.
+ *
+ * The above are rough estimates for _us-east-1_, check out the
+ * [Network Load Balancer pricing](https://aws.amazon.com/elasticloadbalancing/pricing/)
+ * for more details.
+ */
+export declare class Service extends Service_base {
+    private readonly reach;
+    constructor(name: string, args: ServiceArgs, opts?: ComponentResourceOptions);
+    private createLoadBalancer;
+    private attachToAlb;
+    private createCloudmapService;
+    /**
+     * The URL of the service.
+     *
+     * If `loadBalancer.domain` is set, this is the URL with the custom domain.
+     * Otherwise, it's the auto-generated load balancer URL.
+     */
+    get url(): Output<string>;
+    /**
+     * The name of the Cloud Map service. This is useful for service discovery.
+     */
+    get service(): Output<string>;
+    /**
+     * Linking a service gives the linked resource its `url`, when it has a load balancer,
+     * and its `service` host name.
+     */
+    link(): {
+        properties: {
+            url: Output<string> | undefined;
+            service: Output<string | undefined>;
+        };
+    };
+}
+export {};
+//# sourceMappingURL=service.d.ts.map