agent-claw: automated task changes

cdk/node_modules/aws-cdk-lib/aws-ecs/lib/fargate/fargate-service.d.ts

@@ -0,0 +1,163 @@
+import type { Construct } from 'constructs';
+import type * as ec2 from '../../../aws-ec2';
+import type * as elb from '../../../aws-elasticloadbalancing';
+import { AvailabilityZoneRebalancing } from '../availability-zone-rebalancing';
+import type { BaseServiceOptions, IBaseService, IService } from '../base/base-service';
+import { BaseService } from '../base/base-service';
+import type { TaskDefinition } from '../base/task-definition';
+import type { ICluster } from '../cluster';
+/**
+ * The properties for defining a service using the Fargate launch type.
+ */
+export interface FargateServiceProps extends BaseServiceOptions {
+    /**
+     * The task definition to use for tasks in the service.
+     *
+     * [disable-awslint:ref-via-interface]
+     */
+    readonly taskDefinition: TaskDefinition;
+    /**
+     * Specifies whether the task's elastic network interface receives a public IP address.
+     *
+     * If true, each task will receive a public IP address.
+     *
+     * @default false
+     */
+    readonly assignPublicIp?: boolean;
+    /**
+     * The subnets to associate with the service.
+     *
+     * @default - Public subnets if `assignPublicIp` is set, otherwise the first available one of Private, Isolated, Public, in that order.
+     */
+    readonly vpcSubnets?: ec2.SubnetSelection;
+    /**
+     * The security groups to associate with the service. If you do not specify a security group, a new security group is created.
+     *
+     * @default - A new security group is created.
+     */
+    readonly securityGroups?: ec2.ISecurityGroup[];
+    /**
+     * The platform version on which to run your service.
+     *
+     * If one is not specified, the LATEST platform version is used by default. For more information, see
+     * [AWS Fargate Platform Versions](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html)
+     * in the Amazon Elastic Container Service Developer Guide.
+     *
+     * @default Latest
+     */
+    readonly platformVersion?: FargatePlatformVersion;
+    /**
+     * Whether to use Availability Zone rebalancing for the service.
+     *
+     * If enabled, `maxHealthyPercent` must be greater than 100, and the service must not be a target
+     * of a Classic Load Balancer.
+     *
+     * @see https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-rebalancing.html
+     * @default AvailabilityZoneRebalancing.ENABLED
+     */
+    readonly availabilityZoneRebalancing?: AvailabilityZoneRebalancing;
+}
+/**
+ * The interface for a service using the Fargate launch type on an ECS cluster.
+ */
+export interface IFargateService extends IService {
+}
+/**
+ * The properties to import from the service using the Fargate launch type.
+ */
+export interface FargateServiceAttributes {
+    /**
+     * The cluster that hosts the service.
+     */
+    readonly cluster: ICluster;
+    /**
+     * The service ARN.
+     *
+     * @default - either this, or `serviceName`, is required
+     */
+    readonly serviceArn?: string;
+    /**
+     * The name of the service.
+     *
+     * @default - either this, or `serviceArn`, is required
+     */
+    readonly serviceName?: string;
+}
+/**
+ * This creates a service using the Fargate launch type on an ECS cluster.
+ *
+ * Can also be used with Managed Instances compatible task definitions when using
+ * capacity provider strategies.
+ *
+ * @resource AWS::ECS::Service
+ */
+export declare class FargateService extends BaseService implements IFargateService {
+    /**
+     * Uniquely identifies this class.
+     */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /**
+     * Imports from the specified service ARN.
+     */
+    static fromFargateServiceArn(scope: Construct, id: string, fargateServiceArn: string): IFargateService;
+    /**
+     * Imports from the specified service attributes.
+     */
+    static fromFargateServiceAttributes(scope: Construct, id: string, attrs: FargateServiceAttributes): IBaseService;
+    private readonly availabilityZoneRebalancingEnabled;
+    /**
+     * Constructs a new instance of the FargateService class.
+     */
+    constructor(scope: Construct, id: string, props: FargateServiceProps);
+    /**
+     * Registers the service as a target of a Classic Load Balancer (CLB).
+     *
+     * Don't call this. Call `loadBalancer.addTarget()` instead.
+     *
+     * @override
+     */
+    attachToClassicLB(loadBalancer: elb.LoadBalancer): void;
+}
+/**
+ * The platform version on which to run your service.
+ *
+ * @see https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html
+ */
+export declare enum FargatePlatformVersion {
+    /**
+     * The latest, recommended platform version.
+     */
+    LATEST = "LATEST",
+    /**
+     * Version 1.4.0
+     *
+     * Supports EFS endpoints, CAP_SYS_PTRACE Linux capability,
+     * network performance metrics in CloudWatch Container Insights,
+     * consolidated 20 GB ephemeral volume.
+     */
+    VERSION1_4 = "1.4.0",
+    /**
+     * Version 1.3.0
+     *
+     * Supports secrets, task recycling.
+     */
+    VERSION1_3 = "1.3.0",
+    /**
+     * Version 1.2.0
+     *
+     * Supports private registries.
+     */
+    VERSION1_2 = "1.2.0",
+    /**
+     * Version 1.1.0
+     *
+     * Supports task metadata, health checks, service discovery.
+     */
+    VERSION1_1 = "1.1.0",
+    /**
+     * Initial release
+     *
+     * Based on Amazon Linux 2017.09.
+     */
+    VERSION1_0 = "1.0.0"
+}

cdk/node_modules/aws-cdk-lib/aws-ecs/lib/fargate/fargate-task-definition.d.ts

@@ -0,0 +1,136 @@
+import type { Construct } from 'constructs';
+import type { CommonTaskDefinitionAttributes, CommonTaskDefinitionProps, ITaskDefinition } from '../base/task-definition';
+import { NetworkMode, PidMode, TaskDefinition } from '../base/task-definition';
+import type { RuntimePlatform } from '../runtime-platform';
+/**
+ * The properties for a task definition.
+ */
+export interface FargateTaskDefinitionProps extends CommonTaskDefinitionProps {
+    /**
+     * The number of cpu units used by the task. For tasks using the Fargate launch type,
+     * this field is required and you must use one of the following values,
+     * which determines your range of valid values for the memory parameter:
+     *
+     * 256 (.25 vCPU) - Available memory values: 512 (0.5 GB), 1024 (1 GB), 2048 (2 GB)
+     *
+     * 512 (.5 vCPU) - Available memory values: 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB)
+     *
+     * 1024 (1 vCPU) - Available memory values: 2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB)
+     *
+     * 2048 (2 vCPU) - Available memory values: Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB)
+     *
+     * 4096 (4 vCPU) - Available memory values: Between 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB)
+     *
+     * 8192 (8 vCPU) - Available memory values: Between 16384 (16 GB) and 61440 (60 GB) in increments of 4096 (4 GB)
+     *
+     * 16384 (16 vCPU) - Available memory values: Between 32768 (32 GB) and 122880 (120 GB) in increments of 8192 (8 GB)
+     *
+     * Note: For windows platforms, this field is not enforced at runtime. However, it is still required as it is used to determine
+     * the instance type and size that tasks run on.
+     *
+     * @default 256
+     */
+    readonly cpu?: number;
+    /**
+     * The amount (in MiB) of memory used by the task. For tasks using the Fargate launch type,
+     * this field is required and you must use one of the following values, which determines your range of valid values for the cpu parameter:
+     *
+     * 512 (0.5 GB), 1024 (1 GB), 2048 (2 GB) - Available cpu values: 256 (.25 vCPU)
+     *
+     * 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - Available cpu values: 512 (.5 vCPU)
+     *
+     * 2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) - Available cpu values: 1024 (1 vCPU)
+     *
+     * Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) - Available cpu values: 2048 (2 vCPU)
+     *
+     * Between 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB) - Available cpu values: 4096 (4 vCPU)
+     *
+     * Between 16384 (16 GB) and 61440 (60 GB) in increments of 4096 (4 GB) - Available cpu values: 8192 (8 vCPU)
+     *
+     * Between 32768 (32 GB) and 122880 (120 GB) in increments of 8192 (8 GB) - Available cpu values: 16384 (16 vCPU)
+     *
+     * Note: For windows platforms, this field is not enforced at runtime. However, it is still required as it is used to determine
+     * the instance type and size that tasks run on.
+     *
+     * @default 512
+     */
+    readonly memoryLimitMiB?: number;
+    /**
+     * The amount (in GiB) of ephemeral storage to be allocated to the task. The maximum supported value is 200 GiB.
+     *
+     * NOTE: This parameter is only supported for tasks hosted on AWS Fargate using platform version 1.4.0 or later.
+     *
+     * @default 20
+     */
+    readonly ephemeralStorageGiB?: number;
+    /**
+     * The operating system that your task definitions are running on.
+     *
+     * A runtimePlatform is supported only for tasks using the Fargate launch type.
+     *
+     * @default - Undefined.
+     */
+    readonly runtimePlatform?: RuntimePlatform;
+    /**
+     * The process namespace to use for the containers in the task.
+     *
+     * Only supported for tasks that are hosted on AWS Fargate if the tasks
+     * are using platform version 1.4.0 or later (Linux).  Only the TASK option
+     * is supported for Linux-based Fargate containers. Not supported in
+     * Windows containers. If pidMode is specified for a Fargate task, then
+     * runtimePlatform.operatingSystemFamily must also be specified.  For more
+     * information, see [Task Definition Parameters](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html#task_definition_pidmode).
+     *
+     * @default - PidMode used by the task is not specified
+     */
+    readonly pidMode?: PidMode;
+}
+/**
+ * The interface of a task definition run on a Fargate cluster.
+ */
+export interface IFargateTaskDefinition extends ITaskDefinition {
+}
+/**
+ * Attributes used to import an existing Fargate task definition
+ */
+export interface FargateTaskDefinitionAttributes extends CommonTaskDefinitionAttributes {
+}
+/**
+ * The details of a task definition run on a Fargate cluster.
+ *
+ * @resource AWS::ECS::TaskDefinition
+ */
+export declare class FargateTaskDefinition extends TaskDefinition implements IFargateTaskDefinition {
+    /**
+     * Uniquely identifies this class.
+     */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /**
+     * Imports a task definition from the specified task definition ARN.
+     */
+    static fromFargateTaskDefinitionArn(scope: Construct, id: string, fargateTaskDefinitionArn: string): IFargateTaskDefinition;
+    /**
+     * Import an existing Fargate task definition from its attributes
+     */
+    static fromFargateTaskDefinitionAttributes(scope: Construct, id: string, attrs: FargateTaskDefinitionAttributes): IFargateTaskDefinition;
+    /**
+     * The Docker networking mode to use for the containers in the task. Fargate tasks require the awsvpc network mode.
+     */
+    readonly networkMode: NetworkMode;
+    /**
+     * The amount (in GiB) of ephemeral storage to be allocated to the task.
+     */
+    readonly ephemeralStorageGiB?: number;
+    /**
+     * The number of cpu units used by the task.
+     */
+    readonly cpu: number;
+    /**
+     * The amount (in MiB) of memory used by the task.
+     */
+    readonly memoryMiB: number;
+    /**
+     * Constructs a new instance of the FargateTaskDefinition class.
+     */
+    constructor(scope: Construct, id: string, props?: FargateTaskDefinitionProps);
+}