@studion/infra-code-blocks
Version:
Studion common infra components
186 lines • 7.24 kB
TypeScript
import * as pulumi from '@pulumi/pulumi';
import * as aws from '@pulumi/aws';
import * as awsx from '@pulumi/awsx';
import { TaskSize } from './task-size';
export declare namespace EcsService {
/**
* Represents the EFS-backed persistent storage attached to an ECS service.
* Created automatically when `volumes` are configured.
*/
type PersistentStorage = {
fileSystem: aws.efs.FileSystem;
accessPoint: aws.efs.AccessPoint;
mountTargets: pulumi.Output<aws.efs.MountTarget[]>;
};
/**
* Create a named volume that can be mounted into one or more containers.
* Used with Amazon EFS to enable persistent storage across:
* - Container restarts
* - Multiple containers
*/
type PersistentStorageVolume = {
name: pulumi.Input<string>;
};
/**
* Specifies how an EFS volume is mounted into a container.
* `sourceVolume`: Name of the defined ECS service volume.
* `containerPath`: Path into which the volume is mounted in the container.
*
* @see {@link PersistentStorageVolume} - Required to define volumes before mounting
* @see {@link Container} - Where `mountPoints` are specified
*/
type PersistentStorageMountPoint = {
sourceVolume: pulumi.Input<string>;
containerPath: pulumi.Input<string>;
readOnly?: pulumi.Input<boolean>;
};
/**
* Container configuration for the ECS task definition.
* Multiple containers can be defined to create multi-container tasks.
*/
type Container = {
name: pulumi.Input<string>;
image: pulumi.Input<string>;
portMappings?: pulumi.Input<pulumi.Input<aws.ecs.PortMapping>[]>;
command?: pulumi.Input<pulumi.Input<string>[]>;
mountPoints?: PersistentStorageMountPoint[];
environment?: pulumi.Input<aws.ecs.KeyValuePair[]>;
secrets?: pulumi.Input<aws.ecs.Secret[]>;
dependsOn?: pulumi.Input<aws.ecs.ContainerDependency[]>;
/**
* If `false`, task can continue running if this container fails.
* Should be `false` for containers that execute and then tear down.
*
* Examples: Database migration, or configuration containers
*
* All containers not marked as `false` will be essential by default.
*/
essential?: pulumi.Input<boolean>;
healthCheck?: pulumi.Input<aws.ecs.HealthCheck>;
};
type Tags = {
[key: string]: pulumi.Input<string>;
};
type LoadBalancerConfig = {
containerName: pulumi.Input<string>;
containerPort: pulumi.Input<number>;
targetGroupArn: aws.lb.TargetGroup['arn'];
};
type RoleInlinePolicy = aws.types.input.iam.RoleInlinePolicy;
type Args = {
cluster: pulumi.Input<aws.ecs.Cluster>;
vpc: pulumi.Input<awsx.ec2.Vpc>;
containers: EcsService.Container[];
loadBalancers?: pulumi.Input<LoadBalancerConfig[]>;
volumes?: pulumi.Input<pulumi.Input<EcsService.PersistentStorageVolume>[]>;
/**
* Name to set for the ECS Service.
* @default ${this.name}
*/
name?: pulumi.Input<string>;
/**
* Type of deployment controller to use.
* @default "ECS"
*/
deploymentController?: 'ECS' | 'CODE_DEPLOY' | 'EXTERNAL';
/**
* Number of instances of the task definition to place and keep running.
* @default 1
*/
desiredCount?: pulumi.Input<number>;
/**
* Family for the task definition. Used for grouping of multiple versions.
* @default ${this.name}-task-definition-${stackName}
*/
family?: pulumi.Input<string>;
/**
* CPU and memory size used for running the container.
* Available predefined options are:
* - `small` (0.25 vCPU, 0.5 GB memory)
* - `medium` (0.5 vCPU, 1 GB memory)
* - `large` (1 vCPU memory, 2 GB memory)
* - `xlarge` (2 vCPU, 4 GB memory)
* - `2xlarge` (4 vCPU, 8 GB memory)
* - `3xlarge` (8 vCPU, 16 GB memory)
* @default "small"
*/
size?: pulumi.Input<TaskSize>;
/**
* Name prefix of the AWS CloudWatch log group.
* @default /ecs/${this.name}-
*/
logGroupNamePrefix?: pulumi.Input<string>;
/**
* Custom service security group
* In case no security group is provided, default security group will be automatically created.
*/
securityGroup?: pulumi.Input<aws.ec2.SecurityGroup>;
assignPublicIp?: boolean;
taskExecutionRoleInlinePolicies?: pulumi.Input<pulumi.Input<RoleInlinePolicy>[]>;
taskRoleInlinePolicies?: pulumi.Input<pulumi.Input<RoleInlinePolicy>[]>;
/**
* Registers tasks with AWS Cloud Map and creates discoverable DNS entries for each task.
* Simplifies service-to-service communication by enabling service finding based on DNS records such as `http://serviceName.local`.
*
* @default false
*/
enableServiceAutoDiscovery?: boolean;
autoscaling?: pulumi.Input<{
/**
* Is autoscaling enabled or disabled.
*
* @default false
*/
enabled: boolean;
/**
* Min capacity of the scalable target.
*
* @default 1
*/
minCount?: pulumi.Input<number>;
/**
* Max capacity of the scalable target.
*
* @default 1
*/
maxCount?: pulumi.Input<number>;
}>;
/**
* AWS region used for region-specific ECS settings such as CloudWatch Logs.
* When omitted, the region is resolved from the active AWS provider.
*/
region?: pulumi.Input<string>;
/**
* A map of tags to assign to the resource.
*/
tags?: pulumi.Input<EcsService.Tags>;
};
}
export declare class EcsService extends pulumi.ComponentResource {
name: string;
vpc: pulumi.Output<awsx.ec2.Vpc>;
logGroup: aws.cloudwatch.LogGroup;
taskDefinition: aws.ecs.TaskDefinition;
taskExecutionRole: aws.iam.Role;
taskRole: aws.iam.Role;
service: aws.ecs.Service;
securityGroups: pulumi.Output<aws.ec2.SecurityGroup>[];
serviceDiscoveryService?: aws.servicediscovery.Service;
persistentStorage: pulumi.Output<EcsService.PersistentStorage | undefined>;
constructor(name: string, args: EcsService.Args, opts?: pulumi.ComponentResourceOptions);
static createTcpPortMapping(port: pulumi.Input<number>): aws.ecs.PortMapping;
private createLogGroup;
private createTaskDefinition;
private createTaskDefinitionVolumes;
private createContainerDefinition;
private createTaskExecutionRole;
private createTaskRole;
private addSecurityGroup;
private createDefaultSecurityGroup;
private createEcsService;
private createServiceDiscovery;
private createPrivateDnsNameSpace;
private enableAutoscaling;
private createPersistentStorage;
}
//# sourceMappingURL=index.d.ts.map