@rio-cloud/cdk-v2-constructs 1.0.1-alpha.0

package/lib/fargate/datadog.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataDog = void 0;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const ecs = require("aws-cdk-lib/aws-ecs");
+const lambda = require("aws-cdk-lib/aws-lambda");
+const logs = require("aws-cdk-lib/aws-logs");
+const rio_fargate_service_1 = require("./rio-fargate-service");
+class DataDog {
+    static getFargateContainerEnvironmentVariables(scope, stage, serviceName, version, accountName, teamName) {
+        const { account: accountId, region } = aws_cdk_lib_1.Stack.of(scope);
+        return {
+            // unified tagging, see https://docs.datadoghq.com/getting_started/tagging/unified_service_tagging/?tab=ecs
+            DD_ENV: stage,
+            DD_SERVICE: serviceName,
+            DD_VERSION: version,
+            // APM and tracing, see https://docs.datadoghq.com/tracing/setup_overview/setup/java/?tab=containers
+            DD_LOGS_INJECTION: 'true',
+            DD_SERVICE_MAPPING: this.getApmServiceMappingEnvironmentVariableValue(serviceName),
+            DD_TAGS: this.getTagsEnvironmentVariableValue(accountId, accountName, region, teamName, stage, serviceName, version, 'service'),
+            DD_TRACE_SAMPLE_RATE: '1.0',
+        };
+    }
+    // we add all possible service mappings here even if not used in a particular service to get globally unique names
+    static getApmServiceMappingEnvironmentVariableValue(serviceName) {
+        const serviceMapping = {
+            'database': `${serviceName}-aurora`,
+            'java-aws-sdk': `${serviceName}-aws-sdk`,
+            'kafka': `${serviceName}-kafka`,
+            'mysql': `${serviceName}-aurora`,
+            'redis': `${serviceName}-redis`,
+        };
+        return Object.entries(serviceMapping)
+            .map(([key, value]) => `${key}:${value}`)
+            .join(',');
+    }
+    static getFargateDockerLabels(stage, serviceName, version) {
+        return {
+            'com.datadoghq.tags.env': stage,
+            'com.datadoghq.tags.service': serviceName,
+            'com.datadoghq.tags.version': version,
+        };
+    }
+    static addDatadogSidecar(scope, taskDefinition, accountName, teamName, stage, serviceName, version, datadogApiKeyParameter, datadogSite, datadogLoggingMode, apmGetResourcesToIgnore, cpu, memoryLimitMiB, essential, containerTag) {
+        const { account: accountId, region } = aws_cdk_lib_1.Stack.of(scope);
+        const datadogSidecar = taskDefinition.addContainer('datadog-agent', {
+            image: ecs.ContainerImage.fromRegistry(`public.ecr.aws/datadog/agent:${containerTag}`),
+            logging: this.setupLogging(scope, accountName, teamName, stage, serviceName, version, datadogApiKeyParameter, datadogLoggingMode, datadogSite, 'datadog-sidecar'),
+            cpu,
+            memoryLimitMiB,
+            environment: {
+                // unified tagging, see https://docs.datadoghq.com/getting_started/tagging/unified_service_tagging/?tab=ecs
+                DD_ENV: stage,
+                DD_SERVICE: serviceName,
+                DD_VERSION: version,
+                // APM and tracing see https://docs.datadoghq.com/agent/docker/apm/?tab=linux
+                DD_APM_ENABLED: 'true',
+                DD_APM_IGNORE_RESOURCES: apmGetResourcesToIgnore
+                    .map((apmGetResourceToIgnore) => `GET ${apmGetResourceToIgnore}`)
+                    .join(','),
+                // general settings
+                DD_SITE: datadogSite,
+                DD_TAGS: this.getTagsEnvironmentVariableValue(accountId, accountName, region, teamName, stage, serviceName, version, 'datadog-sidecar'),
+                ECS_FARGATE: 'true',
+                DD_COLLECT_GCE_TAGS: 'false',
+            },
+            // see https://github.com/DataDog/datadog-agent/blob/master/Dockerfiles/agent/amd64/Dockerfile#L171-L172
+            healthCheck: {
+                startPeriod: aws_cdk_lib_1.Duration.minutes(2),
+                interval: aws_cdk_lib_1.Duration.seconds(30),
+                timeout: aws_cdk_lib_1.Duration.seconds(5),
+                retries: 2,
+                command: ['CMD-SHELL', '/probe.sh'],
+            },
+            secrets: {
+                DD_API_KEY: ecs.Secret.fromSsmParameter(datadogApiKeyParameter),
+            },
+            essential: essential,
+        });
+        datadogSidecar.addPortMappings({
+            containerPort: 8125,
+            protocol: ecs.Protocol.UDP,
+        });
+        datadogSidecar.addPortMappings({
+            containerPort: 8126,
+            protocol: ecs.Protocol.TCP,
+        });
+        return datadogSidecar;
+    }
+    static getTagsEnvironmentVariableValue(accountId, accountName, region, teamName, stage, serviceName, version, containerType) {
+        let separator;
+        switch (containerType) {
+            case 'service':
+                separator = ',';
+                break;
+            case 'datadog-sidecar':
+                separator = ' ';
+                break;
+            case 'fluent-bit':
+                separator = ',';
+                break;
+        }
+        const tags = {
+            // unified tagging
+            // overridden by dedicated settings (environment variables/tags)
+            // duplicated here to ensure they are used (and sometimes, not all three values are supported)
+            env: stage,
+            service: serviceName,
+            version,
+            // account/team specific parts
+            account_id: accountId,
+            account_name: accountName,
+            region,
+            team: teamName,
+        };
+        return Object.entries(tags)
+            .map(([key, value]) => `${key}:${value}`)
+            .join(separator);
+    }
+    static addFireLensLogRouter(taskDefinition, cpu, memoryLimitMiB) {
+        return taskDefinition.addFirelensLogRouter('firelens-log-router', {
+            image: ecs.ContainerImage.fromRegistry('public.ecr.aws/aws-observability/aws-for-fluent-bit:latest'),
+            firelensConfig: {
+                type: ecs.FirelensLogRouterType.FLUENTBIT,
+                options: {
+                    configFileType: ecs.FirelensConfigFileType.FILE,
+                    configFileValue: '/fluent-bit/configs/parse-json.conf',
+                    enableECSLogMetadata: true,
+                },
+            },
+            cpu,
+            memoryLimitMiB,
+        });
+    }
+    static setupLogging(scope, accountName, teamName, stage, serviceName, version, datadogApiKeyParameter, datadogLoggingMode, datadogSite, containerType) {
+        let logGroupName;
+        let logGroupId;
+        let containerTypeCamelCase;
+        switch (containerType) {
+            case 'service':
+                logGroupId = 'LogGroupForService';
+                logGroupName = serviceName;
+                containerTypeCamelCase = 'Service';
+                break;
+            case 'datadog-sidecar':
+                logGroupId = 'LogGroupForDatadogSidecar';
+                logGroupName = `${serviceName}-${containerType}`;
+                containerTypeCamelCase = 'DatadogSidecar';
+                break;
+        }
+        const { account: accountId, region } = aws_cdk_lib_1.Stack.of(scope);
+        switch (datadogLoggingMode) {
+            case rio_fargate_service_1.DataDogLoggingMode.AWS_FIRE_LENS:
+                // TODO can we use `secretOptions` here as well, e.g. as in https://github.com/aws-samples/amazon-ecs-firelens-examples/blob/mainline/examples/fluent-bit/datadog/task-definition.json#L33-L36
+                // Probably not, see https://github.com/aws/aws-cdk/issues/8174
+                return ecs.LogDrivers.firelens({
+                    // see https://docs.datadoghq.com/integrations/fluentbit/#configuration-parameters
+                    options: {
+                        Name: 'datadog',
+                        Match: '*',
+                        Host: `http-intake.logs.${datadogSite}`,
+                        TLS: 'on',
+                        apikey: datadogApiKeyParameter.stringValue,
+                        compress: 'gzip',
+                        dd_service: logGroupName,
+                        dd_source: 'rio-fargate',
+                        dd_message_key: 'log',
+                        dd_tags: this.getTagsEnvironmentVariableValue(accountId, accountName, region, teamName, stage, serviceName, version, 'fluent-bit'),
+                        provider: 'ecs',
+                    },
+                });
+            case rio_fargate_service_1.DataDogLoggingMode.FORWARDER_LAMBDA:
+                const logGroupForForwardingLambda = new logs.LogGroup(scope, logGroupId, {
+                    logGroupName,
+                    retention: logs.RetentionDays.ONE_WEEK,
+                });
+                const logForwarderLambdaArn = aws_cdk_lib_1.Fn.importValue('custom-resource-datadog-logforwarder-function-arn');
+                const cfnPermission = new lambda.CfnPermission(scope, `LogForwarderPermission${containerTypeCamelCase}`, {
+                    action: 'lambda:InvokeFunction',
+                    functionName: logForwarderLambdaArn,
+                    principal: `logs.${region}.amazonaws.com`,
+                    sourceArn: logGroupForForwardingLambda.logGroupArn,
+                });
+                const cfnSubscriptionFilter = new logs.CfnSubscriptionFilter(scope, `LogForwarderSubscriptionFilter${containerTypeCamelCase}`, {
+                    destinationArn: logForwarderLambdaArn,
+                    filterPattern: '',
+                    logGroupName: logGroupForForwardingLambda.logGroupName,
+                });
+                cfnSubscriptionFilter.addDependsOn(cfnPermission);
+                return ecs.LogDrivers.awsLogs({
+                    streamPrefix: containerType,
+                    logGroup: logGroupForForwardingLambda,
+                });
+            case rio_fargate_service_1.DataDogLoggingMode.NONE:
+                const logGroupInCloudwatchOnly = new logs.LogGroup(scope, logGroupId, {
+                    retention: logs.RetentionDays.ONE_WEEK,
+                });
+                return ecs.LogDrivers.awsLogs({
+                    streamPrefix: containerType,
+                    logGroup: logGroupInCloudwatchOnly,
+                });
+        }
+    }
+    static ensureLoggingAndMonitoringAreReadyBeforeServiceStarts(rioFargateService) {
+        var _a;
+        rioFargateService.serviceContainerDefinition.addContainerDependencies({
+            container: rioFargateService.datadogSideCarContainerDefinition,
+            condition: ecs.ContainerDependencyCondition.HEALTHY,
+        });
+        if (rioFargateService.logRouterContainerDefinition) {
+            rioFargateService.serviceContainerDefinition.addContainerDependencies({
+                container: rioFargateService.logRouterContainerDefinition,
+                condition: ecs.ContainerDependencyCondition.START,
+            });
+            if (((_a = rioFargateService.datadogSideCarContainerDefinition.logDriverConfig) === null || _a === void 0 ? void 0 : _a.logDriver) === 'awsfirelens') {
+                rioFargateService.datadogSideCarContainerDefinition.addContainerDependencies({
+                    container: rioFargateService.logRouterContainerDefinition,
+                    condition: ecs.ContainerDependencyCondition.START,
+                });
+            }
+        }
+    }
+}
+exports.DataDog = DataDog;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datadog.js","sourceRoot":"","sources":["../../src/fargate/datadog.ts"],"names":[],"mappings":";;;AAAA,6CAAkD;AAClD,2CAA2C;AAC3C,iDAAiD;AACjD,6CAA6C;AAG7C,+DAA8E;AAE9E,MAAa,OAAO;IAEX,MAAM,CAAC,uCAAuC,CACnD,KAAgB,EAChB,KAAa,EACb,WAAmB,EACnB,OAAe,EACf,WAAmB,EACnB,QAAgB;QAGhB,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,mBAAK,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;QAEvD,OAAO;YACL,2GAA2G;YAC3G,MAAM,EAAE,KAAK;YACb,UAAU,EAAE,WAAW;YACvB,UAAU,EAAE,OAAO;YACnB,oGAAoG;YACpG,iBAAiB,EAAE,MAAM;YACzB,kBAAkB,EAAE,IAAI,CAAC,4CAA4C,CAAC,WAAW,CAAC;YAClF,OAAO,EAAE,IAAI,CAAC,+BAA+B,CAC3C,SAAS,EACT,WAAW,EACX,MAAM,EACN,QAAQ,EACR,KAAK,EACL,WAAW,EACX,OAAO,EACP,SAAS,CACV;YACD,oBAAoB,EAAE,KAAK;SAC5B,CAAC;IACJ,CAAC;IAED,kHAAkH;IAClH,MAAM,CAAC,4CAA4C,CAAC,WAAmB;QAErE,MAAM,cAAc,GAAG;YACrB,UAAU,EAAE,GAAG,WAAW,SAAS;YACnC,cAAc,EAAE,GAAG,WAAW,UAAU;YACxC,OAAO,EAAE,GAAG,WAAW,QAAQ;YAC/B,OAAO,EAAE,GAAG,WAAW,SAAS;YAChC,OAAO,EAAE,GAAG,WAAW,QAAQ;SAChC,CAAC;QAEF,OAAO,MAAM,CAAC,OAAO,CAAC,cAAc,CAAC;aAClC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,IAAI,KAAK,EAAE,CAAC;aACxC,IAAI,CAAC,GAAG,CAAC,CAAC;IACf,CAAC;IAEM,MAAM,CAAC,sBAAsB,CAAC,KAAa,EAAE,WAAmB,EAAE,OAAe;QACtF,OAAO;YACL,wBAAwB,EAAE,KAAK;YAC/B,4BAA4B,EAAE,WAAW;YACzC,4BAA4B,EAAE,OAAO;SACtC,CAAC;IACJ,CAAC;IAEM,MAAM,CAAC,iBAAiB,CAC7B,KAAgB,EAChB,cAAkC,EAClC,WAAmB,EACnB,QAAgB,EAChB,KAAa,EACb,WAAmB,EACnB,OAAe,EACf,sBAA4C,EAC5C,WAAmB,EACnB,kBAAsC,EACtC,uBAAiC,EACjC,GAAW,EACX,cAAsB,EACtB,SAAkB,EAClB,YAAoB;QAGpB,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,mBAAK,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;QACvD,MAAM,cAAc,GAAG,cAAc,CAAC,YAAY,CAAC,eAAe,EAAE;YAClE,KAAK,EAAE,GAAG,CAAC,cAAc,CAAC,YAAY,CAAC,gCAAgC,YAAY,EAAE,CAAC;YACtF,OAAO,EAAE,IAAI,CAAC,YAAY,CACxB,KAAK,EACL,WAAW,EACX,QAAQ,EACR,KAAK,EACL,WAAW,EACX,OAAO,EACP,sBAAsB,EACtB,kBAAkB,EAClB,WAAW,EACX,iBAAiB,CAClB;YACD,GAAG;YACH,cAAc;YACd,WAAW,EAAE;gBACX,2GAA2G;gBAC3G,MAAM,EAAE,KAAK;gBACb,UAAU,EAAE,WAAW;gBACvB,UAAU,EAAE,OAAO;gBACnB,6EAA6E;gBAC7E,cAAc,EAAE,MAAM;gBACtB,uBAAuB,EAAE,uBAAuB;qBAC7C,GAAG,CAAC,CAAC,sBAAsB,EAAE,EAAE,CAAC,OAAO,sBAAsB,EAAE,CAAC;qBAChE,IAAI,CAAC,GAAG,CAAC;gBACZ,mBAAmB;gBACnB,OAAO,EAAE,WAAW;gBACpB,OAAO,EAAE,IAAI,CAAC,+BAA+B,CAC3C,SAAS,EACT,WAAW,EACX,MAAM,EACN,QAAQ,EACR,KAAK,EACL,WAAW,EACX,OAAO,EACP,iBAAiB,CAClB;gBACD,WAAW,EAAE,MAAM;gBACnB,mBAAmB,EAAE,OAAO;aAC7B;YACD,wGAAwG;YACxG,WAAW,EAAE;gBACX,WAAW,EAAE,sBAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;gBAChC,QAAQ,EAAE,sBAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;gBAC9B,OAAO,EAAE,sBAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;gBAC5B,OAAO,EAAE,CAAC;gBACV,OAAO,EAAE,CAAC,WAAW,EAAE,WAAW,CAAC;aACpC;YACD,OAAO,EAAE;gBACP,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,gBAAgB,CAAC,sBAAsB,CAAC;aAChE;YACD,SAAS,EAAE,SAAS;SACrB,CAAC,CAAC;QAEH,cAAc,CAAC,eAAe,CAAC;YAC7B,aAAa,EAAE,IAAI;YACnB,QAAQ,EAAE,GAAG,CAAC,QAAQ,CAAC,GAAG;SAC3B,CAAC,CAAC;QAEH,cAAc,CAAC,eAAe,CAAC;YAC7B,aAAa,EAAE,IAAI;YACnB,QAAQ,EAAE,GAAG,CAAC,QAAQ,CAAC,GAAG;SAC3B,CAAC,CAAC;QAEH,OAAO,cAAc,CAAC;IACxB,CAAC;IAED,MAAM,CAAC,+BAA+B,CACpC,SAAiB,EACjB,WAAmB,EACnB,MAAc,EACd,QAAgB,EAChB,KAAa,EACb,WAAmB,EACnB,OAAe,EACf,aAA2D;QAG3D,IAAI,SAAiB,CAAC;QAEtB,QAAQ,aAAa,EAAE;YAErB,KAAK,SAAS;gBACZ,SAAS,GAAG,GAAG,CAAC;gBAChB,MAAM;YAER,KAAK,iBAAiB;gBACpB,SAAS,GAAG,GAAG,CAAC;gBAChB,MAAM;YAER,KAAK,YAAY;gBACf,SAAS,GAAG,GAAG,CAAC;gBAChB,MAAM;SACT;QAED,MAAM,IAAI,GAAG;YACX,kBAAkB;YAClB,gEAAgE;YAChE,8FAA8F;YAC9F,GAAG,EAAE,KAAK;YACV,OAAO,EAAE,WAAW;YACpB,OAAO;YACP,8BAA8B;YAC9B,UAAU,EAAE,SAAS;YACrB,YAAY,EAAE,WAAW;YACzB,MAAM;YACN,IAAI,EAAE,QAAQ;SACf,CAAC;QACF,OAAO,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC;aACxB,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,IAAI,KAAK,EAAE,CAAC;aACxC,IAAI,CAAC,SAAS,CAAC,CAAC;IACrB,CAAC;IAEM,MAAM,CAAC,oBAAoB,CAChC,cAAkC,EAClC,GAAW,EACX,cAAsB;QAGtB,OAAO,cAAc,CAAC,oBAAoB,CAAC,qBAAqB,EAAE;YAChE,KAAK,EAAE,GAAG,CAAC,cAAc,CAAC,YAAY,CAAC,4DAA4D,CAAC;YACpG,cAAc,EAAE;gBACd,IAAI,EAAE,GAAG,CAAC,qBAAqB,CAAC,SAAS;gBACzC,OAAO,EAAE;oBACP,cAAc,EAAE,GAAG,CAAC,sBAAsB,CAAC,IAAI;oBAC/C,eAAe,EAAE,qCAAqC;oBACtD,oBAAoB,EAAE,IAAI;iBAC3B;aACF;YACD,GAAG;YACH,cAAc;SACf,CAAC,CAAC;IACL,CAAC;IAEM,MAAM,CAAC,YAAY,CACxB,KAAgB,EAChB,WAAmB,EACnB,QAAgB,EAChB,KAAa,EACb,WAAmB,EACnB,OAAe,EACf,sBAA4C,EAC5C,kBAAsC,EACtC,WAAmB,EACnB,aAA4C;QAG5C,IAAI,YAAoB,CAAC;QACzB,IAAI,UAAkB,CAAC;QACvB,IAAI,sBAAsB,CAAC;QAE3B,QAAQ,aAAa,EAAE;YAErB,KAAK,SAAS;gBACZ,UAAU,GAAG,oBAAoB,CAAC;gBAClC,YAAY,GAAG,WAAW,CAAC;gBAC3B,sBAAsB,GAAG,SAAS,CAAC;gBACnC,MAAM;YAER,KAAK,iBAAiB;gBACpB,UAAU,GAAG,2BAA2B,CAAC;gBACzC,YAAY,GAAG,GAAG,WAAW,IAAI,aAAa,EAAE,CAAC;gBACjD,sBAAsB,GAAG,gBAAgB,CAAC;gBAC1C,MAAM;SACT;QAED,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,mBAAK,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;QAEvD,QAAQ,kBAAkB,EAAE;YAE1B,KAAK,wCAAkB,CAAC,aAAa;gBACnC,8LAA8L;gBAC9L,+DAA+D;gBAC/D,OAAO,GAAG,CAAC,UAAU,CAAC,QAAQ,CAAC;oBAC7B,kFAAkF;oBAClF,OAAO,EAAE;wBACP,IAAI,EAAE,SAAS;wBACf,KAAK,EAAE,GAAG;wBACV,IAAI,EAAE,oBAAoB,WAAW,EAAE;wBACvC,GAAG,EAAE,IAAI;wBACT,MAAM,EAAE,sBAAsB,CAAC,WAAW;wBAC1C,QAAQ,EAAE,MAAM;wBAChB,UAAU,EAAE,YAAY;wBACxB,SAAS,EAAE,aAAa;wBACxB,cAAc,EAAE,KAAK;wBACrB,OAAO,EAAE,IAAI,CAAC,+BAA+B,CAC3C,SAAS,EACT,WAAW,EACX,MAAM,EACN,QAAQ,EACR,KAAK,EACL,WAAW,EACX,OAAO,EACP,YAAY,CACb;wBACD,QAAQ,EAAE,KAAK;qBAChB;iBACF,CAAC,CAAC;YAEL,KAAK,wCAAkB,CAAC,gBAAgB;gBACtC,MAAM,2BAA2B,GAAG,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,UAAU,EAAE;oBACvE,YAAY;oBACZ,SAAS,EAAE,IAAI,CAAC,aAAa,CAAC,QAAQ;iBACvC,CAAC,CAAC;gBACH,MAAM,qBAAqB,GAAG,gBAAE,CAAC,WAAW,CAAC,mDAAmD,CAAC,CAAC;gBAClG,MAAM,aAAa,GAAG,IAAI,MAAM,CAAC,aAAa,CAAC,KAAK,EAAE,yBAAyB,sBAAsB,EAAE,EAAE;oBACvG,MAAM,EAAE,uBAAuB;oBAC/B,YAAY,EAAE,qBAAqB;oBACnC,SAAS,EAAE,QAAQ,MAAM,gBAAgB;oBACzC,SAAS,EAAE,2BAA2B,CAAC,WAAW;iBACnD,CAAC,CAAC;gBACH,MAAM,qBAAqB,GAAG,IAAI,IAAI,CAAC,qBAAqB,CAC1D,KAAK,EACL,iCAAiC,sBAAsB,EAAE,EACzD;oBACE,cAAc,EAAE,qBAAqB;oBACrC,aAAa,EAAE,EAAE;oBACjB,YAAY,EAAE,2BAA2B,CAAC,YAAY;iBACvD,CACF,CAAC;gBACF,qBAAqB,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC;gBAClD,OAAO,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC;oBAC5B,YAAY,EAAE,aAAa;oBAC3B,QAAQ,EAAE,2BAA2B;iBACtC,CAAC,CAAC;YAEL,KAAK,wCAAkB,CAAC,IAAI;gBAC1B,MAAM,wBAAwB,GAAG,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,UAAU,EAAE;oBACpE,SAAS,EAAE,IAAI,CAAC,aAAa,CAAC,QAAQ;iBACvC,CAAC,CAAC;gBACH,OAAO,GAAG,CAAC,UAAU,CAAC,OAAO,CAAC;oBAC5B,YAAY,EAAE,aAAa;oBAC3B,QAAQ,EAAE,wBAAwB;iBACnC,CAAC,CAAC;SACN;IACH,CAAC;IAEM,MAAM,CAAC,qDAAqD,CAAC,iBAAoC;;QAEtG,iBAAiB,CAAC,0BAA0B,CAAC,wBAAwB,CAAC;YACpE,SAAS,EAAE,iBAAiB,CAAC,iCAAiC;YAC9D,SAAS,EAAE,GAAG,CAAC,4BAA4B,CAAC,OAAO;SACpD,CAAC,CAAC;QAEH,IAAI,iBAAiB,CAAC,4BAA4B,EAAE;YAClD,iBAAiB,CAAC,0BAA0B,CAAC,wBAAwB,CAAC;gBACpE,SAAS,EAAE,iBAAiB,CAAC,4BAA4B;gBACzD,SAAS,EAAE,GAAG,CAAC,4BAA4B,CAAC,KAAK;aAClD,CAAC,CAAC;YAEH,IAAI,OAAA,iBAAiB,CAAC,iCAAiC,CAAC,eAAe,0CAAE,SAAS,MAAK,aAAa,EAAE;gBACpG,iBAAiB,CAAC,iCAAiC,CAAC,wBAAwB,CAAC;oBAC3E,SAAS,EAAE,iBAAiB,CAAC,4BAA4B;oBACzD,SAAS,EAAE,GAAG,CAAC,4BAA4B,CAAC,KAAK;iBAClD,CAAC,CAAC;aACJ;SACF;IACH,CAAC;CACF;AAjVD,0BAiVC","sourcesContent":["import { Stack, Duration, Fn } from 'aws-cdk-lib';\nimport * as ecs from 'aws-cdk-lib/aws-ecs';\nimport * as lambda from 'aws-cdk-lib/aws-lambda';\nimport * as logs from 'aws-cdk-lib/aws-logs';\nimport * as ssm from 'aws-cdk-lib/aws-ssm';\nimport { Construct } from 'constructs';\nimport { DataDogLoggingMode, RioFargateService } from './rio-fargate-service';\n\nexport class DataDog {\n\n  public static getFargateContainerEnvironmentVariables(\n    scope: Construct,\n    stage: string,\n    serviceName: string,\n    version: string,\n    accountName: string,\n    teamName: string,\n  ): { [key: string]: string } {\n\n    const { account: accountId, region } = Stack.of(scope);\n\n    return {\n      // unified tagging, see https://docs.datadoghq.com/getting_started/tagging/unified_service_tagging/?tab=ecs\n      DD_ENV: stage,\n      DD_SERVICE: serviceName,\n      DD_VERSION: version,\n      // APM and tracing, see https://docs.datadoghq.com/tracing/setup_overview/setup/java/?tab=containers\n      DD_LOGS_INJECTION: 'true',\n      DD_SERVICE_MAPPING: this.getApmServiceMappingEnvironmentVariableValue(serviceName),\n      DD_TAGS: this.getTagsEnvironmentVariableValue(\n        accountId,\n        accountName,\n        region,\n        teamName,\n        stage,\n        serviceName,\n        version,\n        'service',\n      ),\n      DD_TRACE_SAMPLE_RATE: '1.0', // see https://ddtrace.readthedocs.io/en/stable/configuration.html\n    };\n  }\n\n  // we add all possible service mappings here even if not used in a particular service to get globally unique names\n  static getApmServiceMappingEnvironmentVariableValue(serviceName: string): string {\n\n    const serviceMapping = {\n      'database': `${serviceName}-aurora`,\n      'java-aws-sdk': `${serviceName}-aws-sdk`,\n      'kafka': `${serviceName}-kafka`,\n      'mysql': `${serviceName}-aurora`,\n      'redis': `${serviceName}-redis`,\n    };\n\n    return Object.entries(serviceMapping)\n      .map(([key, value]) => `${key}:${value}`)\n      .join(',');\n  }\n\n  public static getFargateDockerLabels(stage: string, serviceName: string, version: string): { [key: string]: string } {\n    return {\n      'com.datadoghq.tags.env': stage,\n      'com.datadoghq.tags.service': serviceName,\n      'com.datadoghq.tags.version': version,\n    };\n  }\n\n  public static addDatadogSidecar(\n    scope: Construct,\n    taskDefinition: ecs.TaskDefinition,\n    accountName: string,\n    teamName: string,\n    stage: string,\n    serviceName: string,\n    version: string,\n    datadogApiKeyParameter: ssm.IStringParameter,\n    datadogSite: string,\n    datadogLoggingMode: DataDogLoggingMode,\n    apmGetResourcesToIgnore: string[],\n    cpu: number,\n    memoryLimitMiB: number,\n    essential: boolean,\n    containerTag: string,\n  ): ecs.ContainerDefinition {\n\n    const { account: accountId, region } = Stack.of(scope);\n    const datadogSidecar = taskDefinition.addContainer('datadog-agent', {\n      image: ecs.ContainerImage.fromRegistry(`public.ecr.aws/datadog/agent:${containerTag}`),\n      logging: this.setupLogging(\n        scope,\n        accountName,\n        teamName,\n        stage,\n        serviceName,\n        version,\n        datadogApiKeyParameter,\n        datadogLoggingMode,\n        datadogSite,\n        'datadog-sidecar',\n      ),\n      cpu,\n      memoryLimitMiB,\n      environment: {\n        // unified tagging, see https://docs.datadoghq.com/getting_started/tagging/unified_service_tagging/?tab=ecs\n        DD_ENV: stage,\n        DD_SERVICE: serviceName,\n        DD_VERSION: version,\n        // APM and tracing see https://docs.datadoghq.com/agent/docker/apm/?tab=linux\n        DD_APM_ENABLED: 'true',\n        DD_APM_IGNORE_RESOURCES: apmGetResourcesToIgnore\n          .map((apmGetResourceToIgnore) => `GET ${apmGetResourceToIgnore}`)\n          .join(','),\n        // general settings\n        DD_SITE: datadogSite,\n        DD_TAGS: this.getTagsEnvironmentVariableValue(\n          accountId,\n          accountName,\n          region,\n          teamName,\n          stage,\n          serviceName,\n          version,\n          'datadog-sidecar',\n        ),\n        ECS_FARGATE: 'true',\n        DD_COLLECT_GCE_TAGS: 'false',\n      },\n      // see https://github.com/DataDog/datadog-agent/blob/master/Dockerfiles/agent/amd64/Dockerfile#L171-L172\n      healthCheck: {\n        startPeriod: Duration.minutes(2),\n        interval: Duration.seconds(30),\n        timeout: Duration.seconds(5),\n        retries: 2,\n        command: ['CMD-SHELL', '/probe.sh'],\n      },\n      secrets: {\n        DD_API_KEY: ecs.Secret.fromSsmParameter(datadogApiKeyParameter),\n      },\n      essential: essential,\n    });\n\n    datadogSidecar.addPortMappings({\n      containerPort: 8125,\n      protocol: ecs.Protocol.UDP,\n    });\n\n    datadogSidecar.addPortMappings({\n      containerPort: 8126,\n      protocol: ecs.Protocol.TCP,\n    });\n\n    return datadogSidecar;\n  }\n\n  static getTagsEnvironmentVariableValue(\n    accountId: string,\n    accountName: string,\n    region: string,\n    teamName: string,\n    stage: string,\n    serviceName: string,\n    version: string,\n    containerType: 'service' | 'datadog-sidecar' | 'fluent-bit',\n  ): string {\n\n    let separator: string;\n\n    switch (containerType) {\n\n      case 'service':\n        separator = ',';\n        break;\n\n      case 'datadog-sidecar':\n        separator = ' ';\n        break;\n\n      case 'fluent-bit':\n        separator = ',';\n        break;\n    }\n\n    const tags = {\n      // unified tagging\n      // overridden by dedicated settings (environment variables/tags)\n      // duplicated here to ensure they are used (and sometimes, not all three values are supported)\n      env: stage,\n      service: serviceName,\n      version,\n      // account/team specific parts\n      account_id: accountId,\n      account_name: accountName,\n      region,\n      team: teamName,\n    };\n    return Object.entries(tags)\n      .map(([key, value]) => `${key}:${value}`)\n      .join(separator);\n  }\n\n  public static addFireLensLogRouter(\n    taskDefinition: ecs.TaskDefinition,\n    cpu: number,\n    memoryLimitMiB: number,\n  ): ecs.ContainerDefinition {\n\n    return taskDefinition.addFirelensLogRouter('firelens-log-router', {\n      image: ecs.ContainerImage.fromRegistry('public.ecr.aws/aws-observability/aws-for-fluent-bit:latest'),\n      firelensConfig: {\n        type: ecs.FirelensLogRouterType.FLUENTBIT,\n        options: {\n          configFileType: ecs.FirelensConfigFileType.FILE,\n          configFileValue: '/fluent-bit/configs/parse-json.conf',\n          enableECSLogMetadata: true,\n        },\n      },\n      cpu,\n      memoryLimitMiB,\n    });\n  }\n\n  public static setupLogging(\n    scope: Construct,\n    accountName: string,\n    teamName: string,\n    stage: string,\n    serviceName: string,\n    version: string,\n    datadogApiKeyParameter: ssm.IStringParameter,\n    datadogLoggingMode: DataDogLoggingMode,\n    datadogSite: string,\n    containerType: 'service' | 'datadog-sidecar',\n  ): ecs.LogDriver {\n\n    let logGroupName: string;\n    let logGroupId: string;\n    let containerTypeCamelCase;\n\n    switch (containerType) {\n\n      case 'service':\n        logGroupId = 'LogGroupForService';\n        logGroupName = serviceName;\n        containerTypeCamelCase = 'Service';\n        break;\n\n      case 'datadog-sidecar':\n        logGroupId = 'LogGroupForDatadogSidecar';\n        logGroupName = `${serviceName}-${containerType}`;\n        containerTypeCamelCase = 'DatadogSidecar';\n        break;\n    }\n\n    const { account: accountId, region } = Stack.of(scope);\n\n    switch (datadogLoggingMode) {\n\n      case DataDogLoggingMode.AWS_FIRE_LENS:\n        // TODO can we use `secretOptions` here as well, e.g. as in https://github.com/aws-samples/amazon-ecs-firelens-examples/blob/mainline/examples/fluent-bit/datadog/task-definition.json#L33-L36\n        // Probably not, see https://github.com/aws/aws-cdk/issues/8174\n        return ecs.LogDrivers.firelens({\n          // see https://docs.datadoghq.com/integrations/fluentbit/#configuration-parameters\n          options: {\n            Name: 'datadog',\n            Match: '*',\n            Host: `http-intake.logs.${datadogSite}`,\n            TLS: 'on',\n            apikey: datadogApiKeyParameter.stringValue,\n            compress: 'gzip',\n            dd_service: logGroupName,\n            dd_source: 'rio-fargate',\n            dd_message_key: 'log',\n            dd_tags: this.getTagsEnvironmentVariableValue(\n              accountId,\n              accountName,\n              region,\n              teamName,\n              stage,\n              serviceName,\n              version,\n              'fluent-bit',\n            ),\n            provider: 'ecs',\n          },\n        });\n\n      case DataDogLoggingMode.FORWARDER_LAMBDA:\n        const logGroupForForwardingLambda = new logs.LogGroup(scope, logGroupId, {\n          logGroupName,\n          retention: logs.RetentionDays.ONE_WEEK,\n        });\n        const logForwarderLambdaArn = Fn.importValue('custom-resource-datadog-logforwarder-function-arn');\n        const cfnPermission = new lambda.CfnPermission(scope, `LogForwarderPermission${containerTypeCamelCase}`, {\n          action: 'lambda:InvokeFunction',\n          functionName: logForwarderLambdaArn,\n          principal: `logs.${region}.amazonaws.com`,\n          sourceArn: logGroupForForwardingLambda.logGroupArn,\n        });\n        const cfnSubscriptionFilter = new logs.CfnSubscriptionFilter(\n          scope,\n          `LogForwarderSubscriptionFilter${containerTypeCamelCase}`,\n          {\n            destinationArn: logForwarderLambdaArn,\n            filterPattern: '',\n            logGroupName: logGroupForForwardingLambda.logGroupName,\n          },\n        );\n        cfnSubscriptionFilter.addDependsOn(cfnPermission);\n        return ecs.LogDrivers.awsLogs({\n          streamPrefix: containerType,\n          logGroup: logGroupForForwardingLambda,\n        });\n\n      case DataDogLoggingMode.NONE:\n        const logGroupInCloudwatchOnly = new logs.LogGroup(scope, logGroupId, {\n          retention: logs.RetentionDays.ONE_WEEK,\n        });\n        return ecs.LogDrivers.awsLogs({\n          streamPrefix: containerType,\n          logGroup: logGroupInCloudwatchOnly,\n        });\n    }\n  }\n\n  public static ensureLoggingAndMonitoringAreReadyBeforeServiceStarts(rioFargateService: RioFargateService) {\n\n    rioFargateService.serviceContainerDefinition.addContainerDependencies({\n      container: rioFargateService.datadogSideCarContainerDefinition,\n      condition: ecs.ContainerDependencyCondition.HEALTHY,\n    });\n\n    if (rioFargateService.logRouterContainerDefinition) {\n      rioFargateService.serviceContainerDefinition.addContainerDependencies({\n        container: rioFargateService.logRouterContainerDefinition,\n        condition: ecs.ContainerDependencyCondition.START,\n      });\n\n      if (rioFargateService.datadogSideCarContainerDefinition.logDriverConfig?.logDriver === 'awsfirelens') {\n        rioFargateService.datadogSideCarContainerDefinition.addContainerDependencies({\n          container: rioFargateService.logRouterContainerDefinition,\n          condition: ecs.ContainerDependencyCondition.START,\n        });\n      }\n    }\n  }\n}\n\n"]}

package/lib/fargate/rio-fargate-service.d.ts

@@ -0,0 +1,276 @@
+import { Duration } from 'aws-cdk-lib';
+import * as ec2 from 'aws-cdk-lib/aws-ec2';
+import * as ecs from 'aws-cdk-lib/aws-ecs';
+import * as elbv2 from 'aws-cdk-lib/aws-elasticloadbalancingv2';
+import { Construct } from 'constructs';
+/**
+ * Fargate Task Definition Properties.
+ */
+export interface RioFargateServiceProps {
+    /**
+     * The stage of the service, e.g. 'prod'.
+     */
+    readonly stage: string;
+    /**
+     * The Name of the service.
+     */
+    readonly serviceName: string;
+    /**
+     * The version of the service, e.g. the git hash of the corresponding commit.
+     */
+    readonly version: string;
+    /**
+     * The frameworks in uses.
+     *
+     * @default - No frameworks.
+     */
+    readonly frameworks?: Framework[];
+    /**
+     * The VPC of the service.
+     */
+    readonly vpc: ec2.IVpc;
+    /**
+     * Container definition options like image, cpu, memory.
+     */
+    readonly containerDefinitionOption: ContainerDefinitionOptions;
+    /**
+     * Fargate Task Definition Properties.
+     */
+    readonly fargateOptions: FargateTaskDefinitionProps;
+    /**
+     * Loadbalancer options.
+     */
+    readonly loadBalancerOptions?: LoadBalancerOptions;
+    /**
+     * Datadog integration properties
+     */
+    readonly datadogOptions?: DatadogIntegrationProps;
+}
+export declare enum Framework {
+    /**
+     * Spring Framework, Spring Boot, and Spring Cloud AWS.
+     */
+    SPRING = 0
+}
+export interface ContainerDefinitionOptions {
+    /**
+     * The image used to start a container.
+     *
+     * This string is passed directly to the Docker daemon.
+     * Images in the Docker Hub registry are available by default.
+     * Other repositories are specified with either repository-url/image:tag or repository-url/image@digest.
+     */
+    readonly image: ecs.ContainerImage;
+    /**
+     * The environment variables to pass to the container.
+     *
+     * Environment variables set by default are overwritten if passed.
+     *
+     * The default environment variables set are
+     *
+     * DD_ENV: Set same as prop stage
+     *
+     * DD_SERVICE: Set same as prop serviceName
+     *
+     * DD_VERSION: Set same as prop version
+     *
+     * DD_LOGS_INJECTION: true
+     *
+     * DD_SERVICE_MAPPING: database:fargate-web-app-aurora,java-aws-sdk:fargate-web-app-aws-sdk,kafka:fargate-web-app-kafka,mysql:fargate-web-app-aurora
+     *
+     * DD_TAGS: env:prod,service:fargate-web-app,version:notag,account_id:${accountID},account_name:${accountName},region:${AWSRegion},team:${teamName from ssm param /config/team/name}
+     *
+     * DD_TRACE_SAMPLE_RATE: 1.0
+     *
+     * @default - No environment variables.
+     */
+    readonly environment?: {
+        [key: string]: string;
+    };
+    /**
+     * The secret environment variables to pass to the container.
+     *
+     * @default - No secret environment variables.
+     */
+    readonly secrets?: {
+        [key: string]: ecs.Secret;
+    };
+    /**
+     * The health check command and associated configuration parameters for the container.
+     *
+     * @default - Health check configuration from container.
+     */
+    readonly healthCheck?: ecs.HealthCheck;
+}
+export interface FargateTaskDefinitionProps {
+    /**
+     * 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)
+     *
+     * @default 512
+     */
+    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)
+     *
+     * @default 1024
+     */
+    readonly memoryLimitMiB: number;
+    /**
+     * Desired count of running tasks
+     *
+     * @default - When creating the service, default is 1; when updating the service, default uses
+     * the current task number.
+     */
+    readonly desiredCount?: number;
+}
+export interface ListenerRule {
+    readonly priority: number;
+    readonly conditions: elbv2.ListenerCondition[];
+}
+export interface LoadBalancerOptions {
+    /**
+     * Listener for an Application Load Balancer
+     */
+    readonly listener: elbv2.IApplicationListener;
+    /**
+     * One or more path patterns to compare against the request URL.
+     * The maximum size of each string is 128 characters.
+     * The comparison is case sensitive.
+     * The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character).
+     *
+     * Update requires: No interruption
+     */
+    readonly listenerRules: ListenerRule[];
+    /**
+     *  Health check options.
+     */
+    readonly healthCheck: elbv2.HealthCheck;
+    /**
+     *  Health check grace period.
+     */
+    readonly healthCheckGracePeriod: Duration;
+    /**
+     * The time period during which the load balancer sends a newly registered target a linearly increasing share of the traffic to the target group.
+  
+     *The range is 30-900 seconds (15 minutes).
+  
+     * @default undefined
+    */
+    readonly slowStart?: Duration;
+    /**
+     * The amount of time for Elastic Load Balancing to wait before deregistering a target.
+  
+     * The range is 0-3600 seconds.
+  
+     * @default 5
+    */
+    readonly deregistrationDelay?: Duration;
+}
+export interface DatadogIntegrationProps {
+    /**
+     * The minimum number of CPU units to reserve for the container.
+     *
+     * @default - 64
+     */
+    readonly cpu?: number;
+    /**
+     * The amount (in MiB) of memory to present to the container.
+     *
+     * If your container attempts to exceed the allocated memory, the container
+     * is terminated.
+     *
+     * At least one of memoryLimitMiB and memoryReservationMiB is required for non-Fargate services.
+     *
+     * @default - 128
+     */
+    readonly memoryLimitMiB?: number;
+    /**
+     * The logging mode for the service.
+     *
+     * @default - Using the Datadog log forwarder lambda provided by the datadog-integration.
+     */
+    readonly loggingModeForService?: DataDogLoggingMode;
+    /**
+     * The logging mode for the Datadog agent sidecar.
+     *
+     * @default - No logs in Datadog, Cloudwatch only.
+     */
+    readonly loggingModeForDatadogAgent?: DataDogLoggingMode;
+    /**
+     * GET endpoints to ignore in Datadog's APM overview. This is useful to filter out all health check calls.
+  
+      * @default - No endpoints are ignored.
+      */
+    readonly apmGetEndpointsToIgnore?: string[];
+    /**
+     * Configure if the Datadog agent sidecar is marked as essential.
+     *
+     * @default - true.
+     */
+    readonly datadogSidecarEssential?: boolean;
+    /**
+     * Configures the docker image tag for datadog sidecar
+     * @default - 'latest'
+     */
+    readonly datadogSidecarTag?: string;
+}
+export declare enum DataDogLoggingMode {
+    /**
+     * Forward logs directly to Datadog using AWS FireLens as log router,
+     * see https://docs.datadoghq.com/integrations/ecs_fargate/?tab=fluentbitandfirelens#log-collection.
+     */
+    AWS_FIRE_LENS = 0,
+    /**
+     * Store logs in AWS Cloudwatch and use the Datadog log forwarder lambda to forward the logs to Datadog,
+     * see https://docs.datadoghq.com/integrations/ecs_fargate/?tab=logdriver#log-collection.
+     */
+    FORWARDER_LAMBDA = 1,
+    /**
+     * Only log to AWS Cloudwatch without forwarding the logs to Datadog.
+     */
+    NONE = 2
+}
+export declare class RioFargateService extends Construct implements ec2.IConnectable {
+    private readonly DEFAULT_APM_GET_ENDPOINTS_TO_IGNORE;
+    private readonly DEFAULT_DATADOG_SIDECAR_CPU;
+    private readonly DEFAULT_DATADOG_SIDECAR_MEMORY_LIMIT_MIB;
+    private readonly DEFAULT_DATADOG_SIDECAR_ESSENTIAL;
+    private readonly DEFAULT_LOGGING_MODE_FOR_SERVICE;
+    private readonly DEFAULT_LOGGING_MODE_FOR_DATADOG_SIDECAR;
+    private readonly DEFAULT_DEREGISTRATION_DELAY;
+    private readonly DEFAULT_SLOW_START;
+    private readonly DEFAULT_DATADOG_SIDECAR_TAG;
+    private readonly LOG_ROUTER_CPU;
+    private readonly LOG_ROUTER_MEMORY_LIMIT_MIB;
+    readonly serviceContainerDefinition: ecs.ContainerDefinition;
+    readonly datadogSideCarContainerDefinition: ecs.ContainerDefinition;
+    readonly logRouterContainerDefinition?: ecs.ContainerDefinition;
+    readonly taskDefinition: ecs.FargateTaskDefinition;
+    readonly connections: ec2.Connections;
+    readonly service: ecs.FargateService;
+    readonly targetGroup: elbv2.ApplicationTargetGroup | undefined;
+    constructor(scope: Construct, id: string, props: RioFargateServiceProps);
+}