@studion/infra-code-blocks 0.7.0 → 0.8.0-next.0

package/dist/v2/components/ecs-service/index.js

@@ -0,0 +1,362 @@
+"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 policies_1 = require("./policies");
+const config = new pulumi.Config('aws');
+const awsRegion = config.require('region');
+/**
+ * Standard directory permissions:
+ * - Owner: read, write, execute (7)
+ * - Group: read, execute (5)
+ * - Others: read, execute (5)
+ */
+const STANDARD_DIRECTORY_PERMISSIONS = '0755';
+const FIRST_POSIX_NON_ROOT_USER = {
+    userId: 1000,
+    groupId: 1000,
+    permissions: STANDARD_DIRECTORY_PERMISSIONS
+};
+const defaults = {
+    desiredCount: 1,
+    size: 'small',
+    environment: [],
+    secrets: [],
+    volumes: [],
+    enableServiceAutoDiscovery: false,
+    assignPublicIp: false,
+    taskExecutionRoleInlinePolicies: [],
+    taskRoleInlinePolicies: [],
+    autoscaling: {
+        enabled: false,
+        minCount: 1,
+        maxCount: 1,
+    },
+};
+class EcsService extends pulumi.ComponentResource {
+    constructor(name, args, opts = {}) {
+        super('studion:ecs:Service', name, {}, opts);
+        const argsWithDefaults = Object.assign({}, defaults, args);
+        const taskExecutionRoleInlinePolicies = pulumi.output(args.taskExecutionRoleInlinePolicies || defaults.taskExecutionRoleInlinePolicies);
+        const taskRoleInlinePolicies = pulumi.output(args.taskRoleInlinePolicies || defaults.taskRoleInlinePolicies);
+        this.name = name;
+        this.securityGroups = [];
+        this.vpc = pulumi.output(argsWithDefaults.vpc);
+        this.logGroup = this.createLogGroup();
+        this.taskExecutionRole = this.createTaskExecutionRole(taskExecutionRoleInlinePolicies);
+        this.taskRole = this.createTaskRole(taskRoleInlinePolicies);
+        if (argsWithDefaults.volumes.length) {
+            this.persistentStorage = this.createPersistentStorage(this.vpc);
+        }
+        this.taskDefinition = this.createTaskDefinition(argsWithDefaults.containers, pulumi.output(argsWithDefaults.volumes), this.taskExecutionRole, this.taskRole, argsWithDefaults.size, Object.assign(Object.assign({}, constants_1.commonTags), argsWithDefaults.tags));
+        if (argsWithDefaults.enableServiceAutoDiscovery) {
+            this.serviceDiscoveryService = this.createServiceDiscovery();
+        }
+        this.service = this.createEcsService(argsWithDefaults);
+        if (argsWithDefaults.autoscaling.enabled) {
+            this.enableAutoscaling(pulumi.output(argsWithDefaults.cluster).name, this.service.name, argsWithDefaults.autoscaling.minCount, argsWithDefaults.autoscaling.maxCount);
+        }
+        this.registerOutputs();
+    }
+    static createTcpPortMapping(port) {
+        return {
+            containerPort: port,
+            hostPort: port,
+            protocol: 'tcp'
+        };
+    }
+    createLogGroup() {
+        const logGroup = new aws.cloudwatch.LogGroup(`${this.name}-log-group`, {
+            retentionInDays: 14,
+            namePrefix: `/ecs/${this.name}-`,
+            tags: constants_1.commonTags,
+        }, { parent: this });
+        return logGroup;
+    }
+    createTaskDefinition(containers, volumes, taskExecutionRole, taskRole, size, tags) {
+        const stack = pulumi.getStack();
+        const { cpu, memory } = pulumi.output(size).apply(parseSize);
+        const containerDefinitions = containers.map(container => {
+            return this.createContainerDefinition(container);
+        });
+        const taskDefinitionVolumes = this.createTaskDefinitionVolumes(volumes);
+        return pulumi.all(containerDefinitions).apply(containerDefinitions => {
+            return taskDefinitionVolumes.apply(volumes => {
+                return new aws.ecs.TaskDefinition(`${this.name}-task-definition`, Object.assign(Object.assign({ family: `${this.name}-task-definition-${stack}`, networkMode: 'awsvpc', executionRoleArn: taskExecutionRole.arn, taskRoleArn: taskRole.arn, cpu,
+                    memory, requiresCompatibilities: ['FARGATE'], containerDefinitions: JSON.stringify(containerDefinitions) }, ((volumes === null || volumes === void 0 ? void 0 : volumes.length) ? { volumes } : {})), { tags: Object.assign(Object.assign({}, constants_1.commonTags), tags) }), { parent: this });
+            });
+        });
+    }
+    createTaskDefinitionVolumes(volumes) {
+        return volumes.apply(volumes => {
+            if (!volumes.length || !this.persistentStorage)
+                return;
+            return volumes.map(volume => ({
+                name: pulumi.output(volume).name,
+                efsVolumeConfiguration: {
+                    fileSystemId: this.persistentStorage.fileSystem.id,
+                    transitEncryption: 'ENABLED',
+                    authorizationConfig: {
+                        accessPointId: this.persistentStorage.accessPoint.id,
+                        iam: 'ENABLED',
+                    },
+                }
+            }));
+        });
+    }
+    createContainerDefinition(container) {
+        return this.logGroup.name.apply(logGroupName => (Object.assign(Object.assign(Object.assign(Object.assign({}, container), { readonlyRootFilesystem: false }), container.mountPoints && {
+            mountPoints: container.mountPoints.map(mountPoint => pulumi.all([
+                mountPoint.sourceVolume,
+                mountPoint.containerPath,
+                mountPoint.readOnly
+            ]).apply(([sourceVolume, containerPath, readOnly]) => ({
+                containerPath,
+                sourceVolume,
+                readOnly: readOnly !== null && readOnly !== void 0 ? readOnly : false,
+            })))
+        }), { logConfiguration: {
+                logDriver: 'awslogs',
+                options: {
+                    'awslogs-group': logGroupName,
+                    'awslogs-region': awsRegion,
+                    'awslogs-stream-prefix': 'ecs',
+                },
+            } })));
+    }
+    createTaskExecutionRole(inlinePolicies) {
+        const secretManagerSecretsInlinePolicy = {
+            name: `${this.name}-secret-manager-access`,
+            policy: JSON.stringify({
+                Version: '2012-10-17',
+                Statement: [
+                    {
+                        Sid: 'AllowContainerToGetSecretManagerSecrets',
+                        Effect: 'Allow',
+                        Action: ['ssm:GetParameters', 'secretsmanager:GetSecretValue'],
+                        Resource: '*',
+                    },
+                ],
+            }),
+        };
+        const taskExecutionRole = new aws.iam.Role(`${this.name}-task-exec-role`, {
+            namePrefix: `${this.name}-task-exec-role-`,
+            assumeRolePolicy: policies_1.assumeRolePolicy,
+            managedPolicyArns: [
+                'arn:aws:iam::aws:policy/CloudWatchFullAccess',
+                'arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryFullAccess',
+            ],
+            inlinePolicies: inlinePolicies.apply(policies => [
+                secretManagerSecretsInlinePolicy,
+                ...policies,
+            ]),
+            tags: constants_1.commonTags,
+        }, { parent: this });
+        return taskExecutionRole;
+    }
+    createTaskRole(inlinePolicies) {
+        const execCmdInlinePolicy = {
+            name: `${this.name}-exec`,
+            policy: JSON.stringify({
+                Version: '2012-10-17',
+                Statement: [
+                    {
+                        Sid: 'AllowContainerToCreateECSExecSSMChannel',
+                        Effect: 'Allow',
+                        Action: [
+                            'ssmmessages:CreateControlChannel',
+                            'ssmmessages:CreateDataChannel',
+                            'ssmmessages:OpenControlChannel',
+                            'ssmmessages:OpenDataChannel',
+                        ],
+                        Resource: '*',
+                    },
+                ],
+            }),
+        };
+        return new aws.iam.Role(`${this.name}-task-role`, {
+            namePrefix: `${this.name}-task-role-`,
+            assumeRolePolicy: policies_1.assumeRolePolicy,
+            inlinePolicies: inlinePolicies.apply(policies => [
+                execCmdInlinePolicy,
+                ...policies,
+            ]),
+            tags: constants_1.commonTags,
+        }, { parent: this });
+    }
+    addSecurityGroup(securityGroup) {
+        this.securityGroups.push(securityGroup);
+    }
+    createDefaultSecurityGroup() {
+        const securityGroup = pulumi.all([
+            this.vpc,
+            this.vpc.vpcId,
+            this.vpc.vpc.cidrBlock
+        ]).apply(([vpc, vpcId, cidrBlock]) => {
+            return new aws.ec2.SecurityGroup(`${this.name}-service-security-group`, {
+                vpcId,
+                ingress: [
+                    {
+                        fromPort: 0,
+                        toPort: 0,
+                        protocol: '-1',
+                        cidrBlocks: [cidrBlock],
+                    },
+                ],
+                egress: [
+                    {
+                        fromPort: 0,
+                        toPort: 0,
+                        protocol: '-1',
+                        cidrBlocks: ['0.0.0.0/0'],
+                    },
+                ],
+                tags: constants_1.commonTags,
+            }, { parent: this, dependsOn: [vpc] });
+        });
+        this.addSecurityGroup(securityGroup);
+    }
+    createEcsService(ecsServiceArgs) {
+        if (!this.securityGroups.length)
+            this.createDefaultSecurityGroup();
+        const networkConfiguration = {
+            assignPublicIp: ecsServiceArgs.assignPublicIp,
+            subnets: ecsServiceArgs.assignPublicIp ? this.vpc.publicSubnetIds : this.vpc.privateSubnetIds,
+            securityGroups: pulumi
+                .all(this.securityGroups)
+                .apply(groups => groups.map(it => it.id)),
+        };
+        return new aws.ecs.Service(`${this.name}-service`, Object.assign(Object.assign(Object.assign({ name: this.name, cluster: pulumi.output(ecsServiceArgs.cluster).id, launchType: 'FARGATE', desiredCount: ecsServiceArgs.desiredCount, taskDefinition: this.taskDefinition.arn, enableExecuteCommand: true, networkConfiguration }, ecsServiceArgs.loadBalancers && { loadBalancers: ecsServiceArgs.loadBalancers }), this.serviceDiscoveryService && {
+            serviceRegistries: {
+                registryArn: this.serviceDiscoveryService.arn,
+            },
+        }), { tags: Object.assign(Object.assign({}, constants_1.commonTags), ecsServiceArgs.tags) }), { parent: this, });
+    }
+    createServiceDiscovery() {
+        const privateDnsNamespace = this.createPrivateDnsNameSpace();
+        return new aws.servicediscovery.Service(`${this.name}-service-discovery`, {
+            name: this.name,
+            dnsConfig: {
+                namespaceId: privateDnsNamespace.id,
+                dnsRecords: [
+                    {
+                        ttl: 10,
+                        type: 'A',
+                    },
+                ],
+                routingPolicy: 'MULTIVALUE',
+            },
+            tags: constants_1.commonTags,
+        }, { parent: this });
+    }
+    createPrivateDnsNameSpace() {
+        return new aws.servicediscovery.PrivateDnsNamespace(`${this.name}-private-dns-namespace`, {
+            vpc: this.vpc.vpcId,
+            name: this.name,
+            tags: constants_1.commonTags,
+        }, { parent: this });
+    }
+    enableAutoscaling(clusterName, serviceName, minCount, maxCount) {
+        const autoscalingTarget = new aws.appautoscaling.Target(`${this.name}-autoscale-target`, {
+            minCapacity: minCount,
+            maxCapacity: maxCount,
+            resourceId: pulumi.interpolate `service/${clusterName}/${serviceName}`,
+            serviceNamespace: 'ecs',
+            scalableDimension: 'ecs:service:DesiredCount',
+            tags: constants_1.commonTags,
+        }, { parent: this });
+        const memoryAutoscalingPolicy = new aws.appautoscaling.Policy(`${this.name}-memory-autoscale-policy`, {
+            policyType: 'TargetTrackingScaling',
+            resourceId: autoscalingTarget.resourceId,
+            scalableDimension: autoscalingTarget.scalableDimension,
+            serviceNamespace: autoscalingTarget.serviceNamespace,
+            targetTrackingScalingPolicyConfiguration: {
+                predefinedMetricSpecification: {
+                    predefinedMetricType: 'ECSServiceAverageMemoryUtilization',
+                },
+                targetValue: 70,
+            },
+        }, { parent: this });
+        const cpuAutoscalingPolicy = new aws.appautoscaling.Policy(`${this.name}-cpu-autoscale-policy`, {
+            policyType: 'TargetTrackingScaling',
+            resourceId: autoscalingTarget.resourceId,
+            scalableDimension: autoscalingTarget.scalableDimension,
+            serviceNamespace: autoscalingTarget.serviceNamespace,
+            targetTrackingScalingPolicyConfiguration: {
+                predefinedMetricSpecification: {
+                    predefinedMetricType: 'ECSServiceAverageCPUUtilization',
+                },
+                targetValue: 70,
+            },
+        }, { parent: this });
+    }
+    createPersistentStorage(vpc) {
+        const efs = new aws.efs.FileSystem(`${this.name}-efs`, {
+            encrypted: true,
+            lifecyclePolicies: [
+                {
+                    transitionToPrimaryStorageClass: 'AFTER_1_ACCESS',
+                },
+                {
+                    transitionToIa: 'AFTER_7_DAYS',
+                },
+            ],
+            performanceMode: 'generalPurpose',
+            throughputMode: 'bursting',
+            tags: Object.assign(Object.assign({}, constants_1.commonTags), { Name: `${this.name}-data` }),
+        }, { parent: this });
+        const securityGroup = new aws.ec2.SecurityGroup(`${this.name}-persistent-storage-security-group`, {
+            vpcId: vpc.vpcId,
+            ingress: [
+                {
+                    fromPort: 2049,
+                    toPort: 2049,
+                    protocol: 'tcp',
+                    cidrBlocks: [vpc.vpc.cidrBlock],
+                },
+            ],
+            tags: constants_1.commonTags,
+        }, { parent: this });
+        this.vpc.privateSubnetIds.apply((subnetIds) => {
+            subnetIds.forEach(subnetId => {
+                const mountTarget = new aws.efs.MountTarget(`${this.name}-mount-target-${subnetId}`, {
+                    fileSystemId: efs.id,
+                    subnetId,
+                    securityGroups: [securityGroup.id],
+                }, { parent: this });
+            });
+        });
+        const accessPoint = new aws.efs.AccessPoint(`${this.name}-efs-ap`, {
+            fileSystemId: efs.id,
+            posixUser: {
+                uid: FIRST_POSIX_NON_ROOT_USER.userId,
+                gid: FIRST_POSIX_NON_ROOT_USER.groupId,
+            },
+            rootDirectory: {
+                path: '/data',
+                creationInfo: {
+                    ownerUid: FIRST_POSIX_NON_ROOT_USER.userId,
+                    ownerGid: FIRST_POSIX_NON_ROOT_USER.groupId,
+                    permissions: FIRST_POSIX_NON_ROOT_USER.permissions,
+                },
+            },
+        });
+        return { fileSystem: efs, accessPoint };
+    }
+}
+exports.EcsService = EcsService;
+function parseSize(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');
+}

package/dist/v2/components/ecs-service/policies.d.ts

@@ -0,0 +1,3 @@
+import * as aws from '@pulumi/aws';
+export declare const assumeRolePolicy: aws.iam.PolicyDocument;
+//# sourceMappingURL=policies.d.ts.map

package/dist/v2/components/ecs-service/policies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policies.d.ts","sourceRoot":"","sources":["../../../../src/v2/components/ecs-service/policies.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,GAAG,MAAM,aAAa,CAAC;AAEnC,eAAO,MAAM,gBAAgB,EAAE,GAAG,CAAC,GAAG,CAAC,cAYtC,CAAC"}

package/dist/v2/components/ecs-service/policies.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assumeRolePolicy = void 0;
+exports.assumeRolePolicy = {
+    Version: '2012-10-17',
+    Statement: [
+        {
+            Action: 'sts:AssumeRole',
+            Principal: {
+                Service: 'ecs-tasks.amazonaws.com',
+            },
+            Effect: 'Allow',
+            Sid: '',
+        },
+    ],
+};

package/dist/v2/components/grafana/dashboards/index.d.ts

@@ -0,0 +1,3 @@
+export { default as WebServerSloDashboardBuilder } from "./web-server-slo";
+export * as panel from './panels';
+//# sourceMappingURL=index.d.ts.map

package/dist/v2/components/grafana/dashboards/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/v2/components/grafana/dashboards/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,4BAA4B,EAAE,MAAM,kBAAkB,CAAC;AAC3E,OAAO,KAAK,KAAK,MAAM,UAAU,CAAC"}

package/dist/v2/components/grafana/dashboards/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.panel = exports.WebServerSloDashboardBuilder = void 0;
+var web_server_slo_1 = require("./web-server-slo");
+Object.defineProperty(exports, "WebServerSloDashboardBuilder", { enumerable: true, get: function () { return web_server_slo_1.default; } });
+exports.panel = require("./panels");

package/dist/v2/components/grafana/dashboards/panels.d.ts

@@ -0,0 +1,6 @@
+import { Grafana } from './types';
+export declare function createStatPercentagePanel(title: string, position: Grafana.Panel.Position, dataSource: string, metric: Grafana.Metric): Grafana.Panel;
+export declare function createTimeSeriesPercentagePanel(title: string, position: Grafana.Panel.Position, dataSource: string, metric: Grafana.Metric): Grafana.Panel;
+export declare function createTimeSeriesPanel(title: string, position: Grafana.Panel.Position, dataSource: string, metric: Grafana.Metric, unit?: string, min?: number, max?: number): Grafana.Panel;
+export declare function createBurnRatePanel(title: string, position: Grafana.Panel.Position, dataSource: string, metric: Grafana.Metric): Grafana.Panel;
+//# sourceMappingURL=panels.d.ts.map

package/dist/v2/components/grafana/dashboards/panels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"panels.d.ts","sourceRoot":"","sources":["../../../../../src/v2/components/grafana/dashboards/panels.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAQlC,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,OAAO,CAAC,KAAK,CAAC,QAAQ,EAChC,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,OAAO,CAAC,MAAM,GACrB,OAAO,CAAC,KAAK,CAsBf;AAED,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,OAAO,CAAC,KAAK,CAAC,QAAQ,EAChC,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,OAAO,CAAC,MAAM,GACrB,OAAO,CAAC,KAAK,CAUf;AAED,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,OAAO,CAAC,KAAK,CAAC,QAAQ,EAChC,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,OAAO,CAAC,MAAM,EACtB,IAAI,CAAC,EAAE,MAAM,EACb,GAAG,CAAC,EAAE,MAAM,EACZ,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,KAAK,CAwBf;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,OAAO,CAAC,KAAK,CAAC,QAAQ,EAChC,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,OAAO,CAAC,MAAM,GACrB,OAAO,CAAC,KAAK,CAkCf"}

package/dist/v2/components/grafana/dashboards/panels.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStatPercentagePanel = createStatPercentagePanel;
+exports.createTimeSeriesPercentagePanel = createTimeSeriesPercentagePanel;
+exports.createTimeSeriesPanel = createTimeSeriesPanel;
+exports.createBurnRatePanel = createBurnRatePanel;
+const percentageFieldConfig = {
+    unit: 'percent',
+    min: 0,
+    max: 100
+};
+function createStatPercentagePanel(title, position, dataSource, metric) {
+    return {
+        title,
+        gridPos: position,
+        type: 'stat',
+        datasource: dataSource,
+        targets: [{
+                expr: metric.query,
+                legendFormat: metric.label
+            }],
+        fieldConfig: {
+            defaults: Object.assign(Object.assign({}, percentageFieldConfig), (metric.thresholds ? {
+                thresholds: {
+                    mode: 'absolute',
+                    steps: metric.thresholds
+                }
+            } : {}))
+        }
+    };
+}
+function createTimeSeriesPercentagePanel(title, position, dataSource, metric) {
+    return createTimeSeriesPanel(title, position, dataSource, metric, percentageFieldConfig.unit, percentageFieldConfig.min, percentageFieldConfig.max);
+}
+function createTimeSeriesPanel(title, position, dataSource, metric, unit, min, max) {
+    return {
+        title,
+        type: 'timeseries',
+        datasource: dataSource,
+        gridPos: position,
+        targets: [{
+                expr: metric.query,
+                legendFormat: metric.label
+            }],
+        fieldConfig: {
+            defaults: Object.assign({ unit,
+                min,
+                max }, (metric.thresholds ? {
+                thresholds: {
+                    mode: 'absolute',
+                    steps: metric.thresholds
+                }
+            } : {}))
+        }
+    };
+}
+function createBurnRatePanel(title, position, dataSource, metric) {
+    return {
+        type: 'stat',
+        title,
+        gridPos: position,
+        datasource: dataSource,
+        targets: [{
+                expr: metric.query,
+                legendFormat: metric.label
+            }],
+        options: {
+            reduceOptions: {
+                calcs: ['last'],
+                fields: '',
+                values: false
+            },
+            colorMode: 'value',
+            graphMode: 'none',
+            textMode: 'value'
+        },
+        fieldConfig: {
+            defaults: {
+                unit: 'none',
+                thresholds: {
+                    mode: 'absolute',
+                    steps: [
+                        { color: 'green', value: null },
+                        { color: 'orange', value: 1 },
+                        { color: 'red', value: 2 }
+                    ]
+                }
+            }
+        },
+    };
+}

package/dist/v2/components/grafana/dashboards/types.d.ts

@@ -0,0 +1,66 @@
+import * as pulumi from '@pulumi/pulumi';
+import * as grafana from '@pulumiverse/grafana';
+export declare namespace Grafana {
+    type Threshold = {
+        value: number | null;
+        color: string;
+    };
+    type Metric = {
+        label: string;
+        query: string;
+        thresholds: Threshold[];
+    };
+    type Args = {
+        title: pulumi.Input<string>;
+        provider: pulumi.Input<grafana.Provider>;
+        tags: pulumi.Input<pulumi.Input<string>[]>;
+    };
+    type Panel = {
+        title: string;
+        gridPos: Panel.Position;
+        type: string;
+        datasource: string;
+        targets: {
+            expr: string;
+            legendFormat: string;
+        }[];
+        fieldConfig: {
+            defaults: {
+                unit?: string;
+                min?: number;
+                max?: number;
+                color?: {
+                    mode: string;
+                };
+                thresholds?: {
+                    mode: string;
+                    steps: Threshold[];
+                };
+                custom?: {
+                    lineInterpolation?: string;
+                    spanNulls: boolean;
+                };
+            };
+        };
+        options?: {
+            colorMode?: string;
+            graphMode?: string;
+            justifyMode?: string;
+            textMode?: string;
+            reduceOptions?: {
+                calcs?: string[];
+                fields?: string;
+                values?: boolean;
+            };
+        };
+    };
+    namespace Panel {
+        type Position = {
+            x: number;
+            y: number;
+            w: number;
+            h: number;
+        };
+    }
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/v2/components/grafana/dashboards/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/v2/components/grafana/dashboards/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,gBAAgB,CAAC;AACzC,OAAO,KAAK,OAAO,MAAM,sBAAsB,CAAC;AAGhD,yBAAiB,OAAO,CAAC;IAIvB,KAAY,SAAS,GAAG;QACtB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;QACrB,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IACF,KAAY,MAAM,GAAG;QACnB,KAAK,EAAE,MAAM,CAAC;QACd,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,SAAS,EAAE,CAAC;KACzB,CAAC;IAEF,KAAY,IAAI,GAAG;QACjB,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QAC5B,QAAQ,EAAE,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QACzC,IAAI,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;KAC5C,CAAC;IAEF,KAAY,KAAK,GAAG;QAClB,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,KAAK,CAAC,QAAQ,CAAC;QACxB,IAAI,EAAE,MAAM,CAAC;QACb,UAAU,EAAE,MAAM,CAAC;QACnB,OAAO,EAAE;YACP,IAAI,EAAE,MAAM,CAAC;YACb,YAAY,EAAE,MAAM,CAAC;SACtB,EAAE,CAAC;QACJ,WAAW,EAAE;YACX,QAAQ,EAAE;gBACR,IAAI,CAAC,EAAE,MAAM,CAAC;gBACd,GAAG,CAAC,EAAE,MAAM,CAAC;gBACb,GAAG,CAAC,EAAE,MAAM,CAAC;gBACb,KAAK,CAAC,EAAE;oBACN,IAAI,EAAE,MAAM,CAAC;iBACd,CAAC;gBACF,UAAU,CAAC,EAAE;oBACX,IAAI,EAAE,MAAM,CAAC;oBACb,KAAK,EAAE,SAAS,EAAE,CAAC;iBACpB,CAAC;gBACF,MAAM,CAAC,EAAE;oBACP,iBAAiB,CAAC,EAAE,MAAM,CAAC;oBAC3B,SAAS,EAAE,OAAO,CAAA;iBACnB,CAAA;aACF,CAAC;SACH,CAAC;QACF,OAAO,CAAC,EAAE;YACR,SAAS,CAAC,EAAE,MAAM,CAAC;YACnB,SAAS,CAAC,EAAE,MAAM,CAAC;YACnB,WAAW,CAAC,EAAE,MAAM,CAAC;YACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;YAClB,aAAa,CAAC,EAAE;gBACd,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;gBACjB,MAAM,CAAC,EAAE,MAAM,CAAC;gBAChB,MAAM,CAAC,EAAE,OAAO,CAAC;aAClB,CAAC;SACH,CAAC;KACH,CAAA;IAED,UAAiB,KAAK,CAAC;QACrB,KAAY,QAAQ,GAAG;YACrB,CAAC,EAAE,MAAM,CAAC;YACV,CAAC,EAAE,MAAM,CAAC;YACV,CAAC,EAAE,MAAM,CAAC;YACV,CAAC,EAAE,MAAM,CAAC;SACX,CAAA;KACF;CACF"}

package/dist/v2/components/grafana/dashboards/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/v2/components/grafana/dashboards/web-server-slo.d.ts

@@ -0,0 +1,17 @@
+import * as pulumi from '@pulumi/pulumi';
+import * as grafana from '@pulumiverse/grafana';
+import { queries as promQ } from '../../prometheus';
+import { Grafana } from './types';
+declare class WebServerSloDashboardBuilder {
+    name: string;
+    title: pulumi.Output<string>;
+    panels: Grafana.Panel[];
+    tags?: pulumi.Output<string[]>;
+    constructor(name: string, args: Grafana.Args);
+    withAvailability(target: number, window: promQ.TimeRange, dataSource: string, prometheusNamespace: string): this;
+    withSuccessRate(target: number, window: promQ.TimeRange, shortWindow: promQ.TimeRange, filter: string, dataSource: string, prometheusNamespace: string): this;
+    withLatency(target: number, targetLatency: number, window: promQ.TimeRange, shortWindow: promQ.TimeRange, filter: string, dataSource: string, prometheusNamespace: string): this;
+    build(provider: pulumi.Output<grafana.Provider>): pulumi.Output<grafana.oss.Dashboard>;
+}
+export default WebServerSloDashboardBuilder;
+//# sourceMappingURL=web-server-slo.d.ts.map

package/dist/v2/components/grafana/dashboards/web-server-slo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-server-slo.d.ts","sourceRoot":"","sources":["../../../../../src/v2/components/grafana/dashboards/web-server-slo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,gBAAgB,CAAC;AACzC,OAAO,KAAK,OAAO,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,MAAM,kBAAkB,CAAA;AACnD,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAQlC,cAAM,4BAA4B;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAC7B,MAAM,EAAE,OAAO,CAAC,KAAK,EAAE,CAAM;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;gBAG7B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,OAAO,CAAC,IAAI;IAMpB,gBAAgB,CACd,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,KAAK,CAAC,SAAS,EACvB,UAAU,EAAE,MAAM,EAClB,mBAAmB,EAAE,MAAM,GAC1B,IAAI;IA0BP,eAAe,CACb,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,KAAK,CAAC,SAAS,EACvB,WAAW,EAAE,KAAK,CAAC,SAAS,EAC5B,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,mBAAmB,EAAE,MAAM,GAC1B,IAAI;IAyCP,WAAW,CACT,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,KAAK,CAAC,SAAS,EACvB,WAAW,EAAE,KAAK,CAAC,SAAS,EAC5B,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,mBAAmB,EAAE,MAAM,GAC1B,IAAI;IA0DP,KAAK,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC;CAuBvF;AAED,eAAe,4BAA4B,CAAC"}