@studion/infra-code-blocks 0.0.2 → 0.0.3

package/dist/components/ecs.js

@@ -1,154 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EcsService = void 0;
-const pulumi = require("@pulumi/pulumi");
-const aws = require("@pulumi/aws");
-const constants_1 = require("../constants");
-const config = new pulumi.Config('aws');
-const awsRegion = config.get('region');
-const assumeRolePolicy = {
-    Version: '2012-10-17',
-    Statement: [
-        {
-            Action: 'sts:AssumeRole',
-            Principal: {
-                Service: 'ecs-tasks.amazonaws.com',
-            },
-            Effect: 'Allow',
-            Sid: '',
-        },
-    ],
-};
-class EcsService extends pulumi.ComponentResource {
-    constructor(name, args, opts = {}) {
-        super('studion:ecs:Service', name, {}, opts);
-        const logGroup = new aws.cloudwatch.LogGroup(`${name}-log-group`, {
-            retentionInDays: 14,
-            name: `/ecs/${name}`,
-        }, { parent: this });
-        const taskExecutionRole = new aws.iam.Role(`${name}-ecs-task-exec-role`, {
-            name: `${name}-ecs-task-exec-role`,
-            assumeRolePolicy,
-            managedPolicyArns: [
-                'arn:aws:iam::aws:policy/CloudWatchFullAccess',
-                'arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryFullAccess',
-            ],
-            inlinePolicies: args.taskExecutionRoleInlinePolicies || [],
-        }, { parent: this });
-        const taskRole = new aws.iam.Role(`${name}-ecs-task-role`, {
-            name: `${name}-ecs-task-role`,
-            assumeRolePolicy,
-            inlinePolicies: args.taskRoleInlinePolicies || [],
-        }, { parent: this });
-        const parsedSize = pulumi.all([args.size || 'small']).apply(([size]) => {
-            const mapCapabilities = ({ cpu, memory }) => ({
-                cpu: String(cpu),
-                memory: String(memory),
-            });
-            if (typeof size === 'string') {
-                return mapCapabilities(constants_1.PredefinedSize[size]);
-            }
-            if (typeof size === 'object') {
-                return mapCapabilities(size);
-            }
-            throw Error('Incorrect EcsService size argument');
-        });
-        const taskDefinition = new aws.ecs.TaskDefinition(`${name}-task-definition`, {
-            family: `${name}-task-definition`,
-            networkMode: 'awsvpc',
-            executionRoleArn: taskExecutionRole.arn,
-            taskRoleArn: taskRole.arn,
-            cpu: parsedSize.cpu,
-            memory: parsedSize.memory,
-            requiresCompatibilities: ['FARGATE'],
-            containerDefinitions: pulumi
-                .all([
-                name,
-                args.image,
-                args.port,
-                args.environment || [],
-                logGroup.name,
-                awsRegion,
-            ])
-                .apply(([containerName, image, port, environment, logGroup, region]) => {
-                return JSON.stringify([
-                    {
-                        name: containerName,
-                        image,
-                        essential: true,
-                        portMappings: [
-                            {
-                                containerPort: port,
-                                protocol: 'tcp',
-                            },
-                        ],
-                        logConfiguration: {
-                            logDriver: 'awslogs',
-                            options: {
-                                'awslogs-group': logGroup,
-                                'awslogs-region': region,
-                                'awslogs-stream-prefix': 'ecs',
-                            },
-                        },
-                        environment,
-                    },
-                ]);
-            }),
-        }, { parent: this });
-        const service = new aws.ecs.Service(`${name}-service`, {
-            name,
-            cluster: args.cluster.id,
-            launchType: 'FARGATE',
-            desiredCount: args.desiredCount || 1,
-            taskDefinition: taskDefinition.arn,
-            loadBalancers: [
-                {
-                    containerName: name,
-                    containerPort: args.port,
-                    targetGroupArn: args.lbTargetGroup.arn,
-                },
-            ],
-            networkConfiguration: {
-                assignPublicIp: true,
-                subnets: args.subnets,
-                securityGroups: args.securityGroupIds,
-            },
-        }, {
-            parent: this,
-            dependsOn: [args.lb, args.lbTargetGroup, args.lbListener],
-        });
-        const autoscalingTarget = new aws.appautoscaling.Target(`${name}-autoscale-target`, {
-            minCapacity: args.minCount || 1,
-            maxCapacity: args.maxCount || 10,
-            resourceId: pulumi.interpolate `service/${args.cluster.name}/${service.name}`,
-            serviceNamespace: 'ecs',
-            scalableDimension: 'ecs:service:DesiredCount',
-        }, { parent: this });
-        const memoryAutoscalingPolicy = new aws.appautoscaling.Policy(`${name}-memory-autoscale-policy`, {
-            policyType: 'TargetTrackingScaling',
-            resourceId: autoscalingTarget.resourceId,
-            scalableDimension: autoscalingTarget.scalableDimension,
-            serviceNamespace: autoscalingTarget.serviceNamespace,
-            targetTrackingScalingPolicyConfiguration: {
-                predefinedMetricSpecification: {
-                    predefinedMetricType: 'ECSServiceAverageMemoryUtilization',
-                },
-                targetValue: 80,
-            },
-        }, { parent: this });
-        const cpuAutoscalingPolicy = new aws.appautoscaling.Policy(`${name}-cpu-autoscale-policy`, {
-            policyType: 'TargetTrackingScaling',
-            resourceId: autoscalingTarget.resourceId,
-            scalableDimension: autoscalingTarget.scalableDimension,
-            serviceNamespace: autoscalingTarget.serviceNamespace,
-            targetTrackingScalingPolicyConfiguration: {
-                predefinedMetricSpecification: {
-                    predefinedMetricType: 'ECSServiceAverageCPUUtilization',
-                },
-                targetValue: 60,
-            },
-        }, { parent: this });
-        this.registerOutputs();
-    }
-}
-exports.EcsService = EcsService;

package/dist/components/rds.d.ts

@@ -1,20 +0,0 @@
-import * as aws from '@pulumi/aws';
-import * as pulumi from '@pulumi/pulumi';
-export type RdsArgs = {
-    dbName: pulumi.Input<string>;
-    username: pulumi.Input<string>;
-    password: pulumi.Input<string>;
-    subnetGroupName: pulumi.Input<string>;
-    securityGroupIds: pulumi.Input<pulumi.Input<string>[]>;
-    publiclyAccessible?: pulumi.Input<boolean>;
-    applyImmediately?: pulumi.Input<boolean>;
-    skipFinalSnapshot?: pulumi.Input<boolean>;
-    allocatedStorage?: pulumi.Input<number>;
-    maxAllocatedStorage?: pulumi.Input<number>;
-    instanceClass?: pulumi.Input<string>;
-};
-export type RdsInstance = aws.rds.Instance;
-export declare class Rds extends pulumi.ComponentResource {
-    instance: RdsInstance;
-    constructor(name: string, args: RdsArgs, opts?: pulumi.ComponentResourceOptions);
-}

package/dist/components/rds.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Rds = void 0;
-const aws = require("@pulumi/aws");
-const pulumi = require("@pulumi/pulumi");
-class Rds extends pulumi.ComponentResource {
-    constructor(name, args, opts = {}) {
-        super('studion:rds:Instance', name, {}, opts);
-        const kms = new aws.kms.Key(`${name}-rds-key`, {
-            customerMasterKeySpec: 'SYMMETRIC_DEFAULT',
-            isEnabled: true,
-            keyUsage: 'ENCRYPT_DECRYPT',
-            multiRegion: false,
-            enableKeyRotation: true,
-        }, { parent: this });
-        this.instance = new aws.rds.Instance(`${name}-rds`, {
-            identifier: name,
-            engine: 'postgres',
-            engineVersion: '14.9',
-            allocatedStorage: args.allocatedStorage || 20,
-            maxAllocatedStorage: args.maxAllocatedStorage || 100,
-            instanceClass: args.instanceClass || 'db.t3.micro',
-            dbName: args.dbName,
-            username: args.username,
-            password: args.password,
-            dbSubnetGroupName: args.subnetGroupName,
-            vpcSecurityGroupIds: args.securityGroupIds,
-            storageEncrypted: true,
-            kmsKeyId: kms.arn,
-            publiclyAccessible: args.publiclyAccessible || false,
-            skipFinalSnapshot: args.skipFinalSnapshot || false,
-            applyImmediately: args.applyImmediately || false,
-            autoMinorVersionUpgrade: true,
-            maintenanceWindow: 'Mon:07:00-Mon:07:30',
-            finalSnapshotIdentifier: `${name}-final-snapshot`,
-            backupWindow: '06:00-06:30',
-            backupRetentionPeriod: 14,
-        }, { parent: this });
-        this.registerOutputs();
-    }
-}
-exports.Rds = Rds;