eoapi-cdk 6.1.0 → 7.0.0

package/integration_tests/cdk/README.md

@@ -0,0 +1,55 @@
+
+# Deployment CDK code for eoapi-cdk deployment tests
+
+This is a wrapper CDK code that is used to test a deployment of the `eoapi-cdk` constructs before a release happens.
+
+## Requirements
+
+- python
+- docker
+- node
+- AWS credentials environment variables configured to point to an account. 
+
+## Installation
+
+Install python dependencies with 
+
+```
+python -m venv .venv
+source .venv/bin/activate
+python -m pip install -r requirements.txt
+```
+
+Install the latest `eoapi-cdk` either from PyPI:
+
+```
+pip install eoapi-cdk
+```
+
+Or alternatively, compile and package from the root of this repository to get the python version of the constructs locally.
+
+Also install node dependencies with 
+
+```
+npm install
+```
+
+Verify that the `cdk` CLI is available. Since `aws-cdk` is installed as a local dependency, you can use the `npx` node package runner tool, that comes with `npm`.
+
+```
+npx cdk --version
+```
+
+## Deployment
+
+First, synthesize the app 
+
+```
+npx cdk synth --all
+```
+
+Then, deploy
+
+```
+npx cdk deploy --all --require-approval never
+```

package/integration_tests/cdk/app.py

@@ -0,0 +1,17 @@
+from aws_cdk import App
+
+from config import build_app_config
+from eoapi_template import pgStacInfra, vpc
+
+app = App()
+
+app_config = build_app_config()
+
+vpc_stack = vpc.VpcStack(scope=app, app_config=app_config)
+
+pgstac_infra_stack = pgStacInfra.pgStacInfraStack(
+    scope=app,
+    vpc=vpc_stack.vpc,
+    app_config=app_config,
+)
+app.synth()

package/integration_tests/cdk/cdk.json

@@ -0,0 +1,32 @@
+{
+  "app": "python3 app.py",
+  "watch": {
+    "include": [
+      "**"
+    ],
+    "exclude": [
+      "README.md",
+      "cdk*.json",
+      "requirements*.txt",
+      "source.bat",
+      "**/*.pyc",
+      "**/*.tmp",
+      "**/__pycache__",
+      "tests",
+      "scripts",
+      "*venv"
+    ]
+  },
+  "context": {
+    "@aws-cdk/aws-apigateway:usagePlanKeyOrderInsensitiveId": true,
+    "@aws-cdk/core:stackRelativeExports": true,
+    "@aws-cdk/aws-rds:lowercaseDbIdentifier": true,
+    "@aws-cdk/aws-lambda:recognizeVersionProps": true,
+    "@aws-cdk/aws-cloudfront:defaultSecurityPolicyTLSv1.2_2021": true,
+    "@aws-cdk-containers/ecs-service-extensions:enableDefaultLogDriver": true,
+    "@aws-cdk/core:target-partitions": [
+      "aws",
+      "aws-cn"
+    ]
+  }
+}

package/integration_tests/cdk/config.py

@@ -0,0 +1,58 @@
+from typing import Dict
+
+import pydantic
+import yaml
+from pydantic_core.core_schema import FieldValidationInfo
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class AppConfig(BaseSettings):
+    model_config = SettingsConfigDict(
+        env_file=".env"
+    )
+    aws_default_account: str = pydantic.Field(
+        description="AWS account ID"
+    )
+    project_id: str = pydantic.Field(
+        description="Project ID", default="eoapi-cdk"
+    )
+    stage: str = pydantic.Field(description="Stage of deployment", default="test")
+    # because of its validator, `tags` should always come after `project_id` and `stage`
+    tags: Dict[str, str] | None = pydantic.Field(
+        description="""Tags to apply to resources. If none provided,
+        will default to the defaults defined in `default_tags`.
+        Note that if tags are passed to the CDK CLI via `--tags`,
+        they will override any tags defined here.""",
+        default=None,
+    )
+    db_instance_type: str = pydantic.Field(
+        description="Database instance type", default="t3.micro"
+    )
+    db_allocated_storage: int = pydantic.Field(
+        description="Allocated storage for the database", default=5
+    )
+
+    @pydantic.field_validator("tags")
+    def default_tags(cls, v, info: FieldValidationInfo):
+        return v or {"project_id": info.data["project_id"], "stage": info.data["stage"]}
+
+    def build_service_name(self, service_id: str) -> str:
+        return f"{self.project_id}-{self.stage}-{service_id}"
+
+
+def build_app_config() -> AppConfig:
+    """Builds the AppConfig object from config.yaml file if exists,
+    otherwise use defaults"""
+    try:
+        with open("config.yaml") as f:
+            print("Loading config from config.yaml")
+            app_config = yaml.safe_load(f)
+            app_config = (
+                {} if app_config is None else app_config
+            )  # if config is empty, set it to an empty dict
+            app_config = AppConfig(**app_config)
+    except FileNotFoundError:
+        # if no config at the expected path, using defaults
+        app_config = AppConfig()
+
+    return app_config

package/integration_tests/cdk/eoapi_template/pgStacInfra.py

@@ -0,0 +1,71 @@
+from aws_cdk import (
+    Stack,
+    aws_ec2,
+    aws_rds
+)
+from constructs import Construct
+from eoapi_cdk import (
+    PgStacApiLambda,
+    PgStacDatabase,
+    TitilerPgstacApiLambda,
+)
+
+from config import AppConfig
+
+
+class pgStacInfraStack(Stack):
+    def __init__(
+        self,
+        scope: Construct,
+        vpc: aws_ec2.Vpc,
+        app_config: AppConfig,
+        **kwargs,
+    ) -> None:
+        super().__init__(
+            scope,
+            id=app_config.build_service_name("pgSTAC-infra"),
+            tags=app_config.tags,
+            **kwargs,
+        )
+
+        pgstac_db = PgStacDatabase(
+            self,
+            "pgstac-db",
+            vpc=vpc,
+            engine=aws_rds.DatabaseInstanceEngine.postgres(
+                version=aws_rds.PostgresEngineVersion.VER_14
+            ),
+            vpc_subnets=aws_ec2.SubnetSelection(
+                subnet_type=aws_ec2.SubnetType.PUBLIC,
+            ),
+            allocated_storage=app_config.db_allocated_storage,
+            instance_type=aws_ec2.InstanceType(app_config.db_instance_type)
+        )
+
+        pgstac_db.db.connections.allow_default_port_from_any_ipv4()
+
+        PgStacApiLambda(
+            self,
+            "pgstac-api",
+            api_env={
+                "NAME": app_config.build_service_name("STAC API"),
+                "description": f"{app_config.stage} STAC API",
+            },
+            db=pgstac_db.db,
+            db_secret=pgstac_db.pgstac_secret
+        )
+
+        TitilerPgstacApiLambda(
+            self,
+            "titiler-pgstac-api",
+            api_env={
+                "NAME": app_config.build_service_name("titiler pgSTAC API"),
+                "description": f"{app_config.stage} titiler pgstac API",
+            },
+            db=pgstac_db.db,
+            db_secret=pgstac_db.pgstac_secret,
+            buckets=[],
+            lambda_function_options={
+                "allow_public_subnet": True,
+            },
+        )

package/integration_tests/cdk/eoapi_template/vpc.py

@@ -0,0 +1,49 @@
+from aws_cdk import Stack, aws_ec2
+from constructs import Construct
+
+from config import AppConfig
+
+
+class VpcStack(Stack):
+    def __init__(self, scope: Construct, app_config: AppConfig, **kwargs) -> None:
+        super().__init__(
+            scope,
+            id=app_config.build_service_name("pgSTAC-vpc"),
+            tags=app_config.tags,
+            **kwargs
+        )
+
+        self.vpc = aws_ec2.Vpc(
+            self,
+            "vpc",
+            subnet_configuration=[
+                aws_ec2.SubnetConfiguration(
+                    name="ingress", subnet_type=aws_ec2.SubnetType.PUBLIC, cidr_mask=24
+                ),
+            ]
+        )
+
+        self.vpc.add_interface_endpoint(
+            "SecretsManagerEndpoint",
+            service=aws_ec2.InterfaceVpcEndpointAwsService.SECRETS_MANAGER,
+        )
+
+        self.vpc.add_interface_endpoint(
+            "CloudWatchEndpoint",
+            service=aws_ec2.InterfaceVpcEndpointAwsService.CLOUDWATCH_LOGS,
+        )
+
+        self.vpc.add_gateway_endpoint(
+            "S3", service=aws_ec2.GatewayVpcEndpointAwsService.S3
+        )
+
+        self.export_value(
+            self.vpc.select_subnets(subnet_type=aws_ec2.SubnetType.PUBLIC)
+            .subnets[0]
+            .subnet_id
+        )
+        self.export_value(
+            self.vpc.select_subnets(subnet_type=aws_ec2.SubnetType.PUBLIC)
+            .subnets[1]
+            .subnet_id
+        )

package/integration_tests/cdk/package-lock.json

@@ -0,0 +1,42 @@
+{
+    "name": "eoapi-template",
+    "version": "0.1.0",
+    "lockfileVersion": 3,
+    "requires": true,
+    "packages": {
+        "": {
+            "name": "eoapi-template",
+            "version": "0.1.0",
+            "dependencies": {
+                "aws-cdk": "^2.99.1"
+            }
+        },
+        "node_modules/aws-cdk": {
+            "version": "2.128.0",
+            "resolved": "https://registry.npmjs.org/aws-cdk/-/aws-cdk-2.128.0.tgz",
+            "integrity": "sha512-epOAr/0WKqmyaKqBc7N0Ky5++93pu+v6yVN9jNOa4JYkAkGbeTS3vR9bj/W0o94jnlgWevG3HNHr83jtRvw/4A==",
+            "bin": {
+                "cdk": "bin/cdk"
+            },
+            "engines": {
+                "node": ">= 14.15.0"
+            },
+            "optionalDependencies": {
+                "fsevents": "2.3.2"
+            }
+        },
+        "node_modules/fsevents": {
+            "version": "2.3.2",
+            "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz",
+            "integrity": "sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==",
+            "hasInstallScript": true,
+            "optional": true,
+            "os": [
+                "darwin"
+            ],
+            "engines": {
+                "node": "^8.16.0 || ^10.6.0 || >=11.0.0"
+            }
+        }
+    }
+}

package/integration_tests/cdk/package.json

@@ -0,0 +1,8 @@
+{
+    "name": "eoapi-template",
+    "version": "0.1.0",
+    "dependencies": {
+      "aws-cdk": "^2.99.1"
+    }
+  }
+  

package/integration_tests/cdk/requirements.txt

@@ -0,0 +1,7 @@
+aws-cdk-lib>=2.99.1
+constructs>=10.0.0,<11.0.0
+pydantic==2.0.2
+pydantic-settings==2.0.1
+python-dotenv==1.0.0
+pyyaml==6.0
+types-PyYAML==6.0.12.10

package/lib/bastion-host/index.js

@@ -158,5 +158,5 @@ class BastionHost extends constructs_1.Construct {
 }
 exports.BastionHost = BastionHost;
 _a = JSII_RTTI_SYMBOL_1;
-BastionHost[_a] = { fqn: "eoapi-cdk.BastionHost", version: "6.1.0" };
+BastionHost[_a] = { fqn: "eoapi-cdk.BastionHost", version: "7.0.0" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Stack,\n  aws_ec2 as ec2,\n  aws_iam as iam,\n  aws_rds as rds,\n  CfnOutput,\n} from \"aws-cdk-lib\";\nimport { Construct } from \"constructs\";\n\n/**\n * The database is located in an isolated subnet, meaning that it is not accessible from the public internet. As such, to interact with the database directly, a user must tunnel through a bastion host.\n *\n * ### Configuring\n *\n * This codebase controls _who_ is allowed to connect to the bastion host. This requires two steps:\n *\n * 1. Adding the IP address from which you are connecting to the `ipv4Allowlist` array\n * 1. Creating a bastion host system user by adding the user's configuration inform to `userdata.yaml`\n *\n * #### Adding an IP address to the `ipv4Allowlist` array\n *\n * The `BastionHost` construct takes in an `ipv4Allowlist` array as an argument. Find your IP address (eg `curl api.ipify.org`) and add that to the array along with the trailing CIDR block (likely `/32` to indicate that you are adding a single IP address).\n *\n * #### Creating a user via `userdata.yaml`\n *\n * Add an entry to the `users` array with a username (likely matching your local systems username, which you can get by running the `whoami` command in your terminal) and a public key (likely your default public key, which you can get by running `cat ~/.ssh/id_*.pub` in your terminal).\n *\n * #### Tips & Tricks when using the Bastion Host\n *\n * **Connecting to RDS Instance via SSM**\n *\n * ```sh\n * aws ssm start-session --target $INSTANCE_ID \\\n * --document-name AWS-StartPortForwardingSessionToRemoteHost \\\n * --parameters '{\n * \"host\": [\n * \"example-db.c5abcdefghij.us-west-2.rds.amazonaws.com\"\n * ],\n * \"portNumber\": [\n * \"5432\"\n * ],\n * \"localPortNumber\": [\n * \"9999\"\n * ]\n * }' \\\n * --profile $AWS_PROFILE\n * ```\n *\n * ```sh\n * psql -h localhost -p 9999 # continue adding username (-U) and db (-d) here...\n * ```\n *\n * Connect directly to Bastion Host:\n *\n * ```sh\n * aws ssm start-session --target $INSTANCE_ID --profile $AWS_PROFILE\n * ```\n *\n * **Setting up an SSH tunnel**\n *\n * In your `~/.ssh/config` file, add an entry like:\n *\n * ```\n * Host db-tunnel\n * Hostname {the-bastion-host-address}\n * LocalForward 9999 {the-db-hostname}:5432\n * ```\n *\n * Then a tunnel can be opened via:\n *\n * ```\n * ssh -N db-tunnel\n * ```\n *\n * And a connection to the DB can be made via:\n *\n * ```\n * psql -h 127.0.0.1 -p 9999 -U {username} -d {database}\n * ```\n *\n * **Handling `REMOTE HOST IDENTIFICATION HAS CHANGED!` error**\n *\n * If you've redeployed a bastion host that you've previously connected to, you may see an error like:\n *\n * ```\n * @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n * @    WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED!     @\n * @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n * IT IS POSSIBLE THAT SOMEONE IS DOING SOMETHING NASTY!\n * Someone could be eavesdropping on you right now (man-in-the-middle attack)!\n * It is also possible that a host key has just been changed.\n * The fingerprint for the ECDSA key sent by the remote host is\n * SHA256:mPnxAOXTpb06PFgI1Qc8TMQ2e9b7goU8y2NdS5hzIr8.\n * Please contact your system administrator.\n * Add correct host key in /Users/username/.ssh/known_hosts to get rid of this message.\n * Offending ECDSA key in /Users/username/.ssh/known_hosts:28\n * ECDSA host key for ec2-12-34-56-789.us-west-2.compute.amazonaws.com has changed and you have requested strict checking.\n * Host key verification failed.\n * ```\n *\n * This is due to the server's fingerprint changing. We can scrub the fingerprint from our system with a command like:\n *\n * ```\n * ssh-keygen -R 12.34.56.789\n * ```\n *\n */\nexport class BastionHost extends Construct {\n  instance: ec2.Instance;\n\n  constructor(scope: Construct, id: string, props: BastionHostProps) {\n    super(scope, id);\n\n    const { stackName } = Stack.of(this);\n\n    // Build ec2 instance\n    this.instance = new ec2.Instance(this, \"bastion-host\", {\n      vpc: props.vpc,\n      vpcSubnets: { subnetType: ec2.SubnetType.PUBLIC },\n      instanceName: `${stackName} bastion host`,\n      instanceType: ec2.InstanceType.of(\n        ec2.InstanceClass.BURSTABLE4_GRAVITON,\n        ec2.InstanceSize.NANO\n      ),\n      machineImage: ec2.MachineImage.latestAmazonLinux({\n        generation: ec2.AmazonLinuxGeneration.AMAZON_LINUX_2,\n        cpuType: ec2.AmazonLinuxCpuType.ARM_64,\n      }),\n      userData: props.userData,\n      userDataCausesReplacement: true,\n    });\n\n    // Assign elastic IP\n    if (props.createElasticIp ?? true) {\n      new ec2.CfnEIP(this, \"IP\", {\n        instanceId: this.instance.instanceId,\n        tags: [{ key: \"Name\", value: stackName }],\n      });\n    }\n\n    // Allow bastion host to connect to db\n    this.instance.connections.allowTo(\n      props.db.connections.securityGroups[0],\n      ec2.Port.tcp(5432),\n      \"Allow connection from bastion host\"\n    );\n\n    // Allow IP access to bastion host\n    for (const ipv4 of props.ipv4Allowlist) {\n      this.instance.connections.allowFrom(\n        ec2.Peer.ipv4(ipv4),\n        ec2.Port.tcp(props.sshPort || 22),\n        \"SSH Access\"\n      );\n    }\n\n    // Integrate with SSM\n    this.instance.addToRolePolicy(\n      new iam.PolicyStatement({\n        actions: [\n          \"ssmmessages:*\",\n          \"ssm:UpdateInstanceInformation\",\n          \"ec2messages:*\",\n        ],\n        resources: [\"*\"],\n      })\n    );\n\n    new CfnOutput(this, \"instance-id-output\", {\n      value: this.instance.instanceId,\n      exportName: `${stackName}-instance-id`,\n    });\n    new CfnOutput(this, \"instance-public-ip-output\", {\n      value: this.instance.instancePublicIp,\n      exportName: `${stackName}-instance-public-ip`,\n    });\n    new CfnOutput(this, \"instance-public-dns-name-output\", {\n      value: this.instance.instancePublicDnsName,\n      exportName: `${stackName}-public-dns-name`,\n    });\n  }\n}\n\nexport interface BastionHostProps {\n  readonly vpc: ec2.IVpc;\n  readonly db: rds.IDatabaseInstance;\n  readonly userData: ec2.UserData;\n  readonly ipv4Allowlist: string[];\n  readonly sshPort?: number;\n\n  /**\n   * Whether or not an elastic IP should be created for the bastion host.\n   *\n   * @default false\n   */\n  readonly createElasticIp?: boolean;\n}\n"]}

package/lib/database/bootstrapper_runtime/handler.py

@@ -2,6 +2,7 @@
 Custom resource lambda handler to bootstrap Postgres db.
 Source: https://github.com/developmentseed/eoAPI/blob/master/deployment/handlers/db_handler.py
 """
+
 import json
 
 import boto3
@@ -58,7 +59,12 @@ def send(
     headers = {"content-type": "", "content-length": str(len(json_responseBody))}
 
     try:
-        response = httpx.put(responseUrl, data=json_responseBody, headers=headers)
+        response = httpx.put(
+            responseUrl,
+            data=json_responseBody,
+            headers=headers,
+            timeout=30,
+        )
         print("Status code: " + response.status_code)
     except Exception as e:
         print("send(..) failed executing httpx.put(..): " + str(e))

package/lib/database/index.d.ts

@@ -41,7 +41,7 @@ export interface PgStacDatabaseProps extends rds.DatabaseInstanceProps {
         [key: string]: any;
     };
     /**
-     * Optional settings for the bootstrapper lambda function. Can be anything that can be configured on the lambda function, but some will be overwritten by values defined here.
+     * Can be used to override the default lambda function properties.
      *
      * @default - defined in the construct.
      */

package/lib/database/index.js

@@ -39,7 +39,7 @@ class PgStacDatabase extends constructs_1.Construct {
             ...props,
         });
         const handler = new aws_cdk_lib_1.aws_lambda.Function(this, "lambda", {
-            // defaults for configurable properties
+            // defaults
             runtime: aws_cdk_lib_1.aws_lambda.Runtime.PYTHON_3_11,
             handler: "handler.handler",
             memorySize: 128,
@@ -49,11 +49,10 @@ class PgStacDatabase extends constructs_1.Construct {
                 file: "bootstrapper_runtime/Dockerfile",
                 buildArgs: { PGSTAC_VERSION: DEFAULT_PGSTAC_VERSION, PYTHON_VERSION: "3.11" }
             }),
-            // overwrites defaults with user-provided configurable properties
-            ...props.bootstrapperLambdaFunctionOptions,
-            // Non configurable properties that are going to be overwritten even if provided by the user
             vpc: hasVpc(this.db) ? this.db.vpc : props.vpc,
-            allowPublicSubnet: true
+            allowPublicSubnet: true,
+            // overwrites defaults with user-provided configurable properties,
+            ...props.bootstrapperLambdaFunctionOptions,
         });
         this.pgstacSecret = new aws_cdk_lib_1.aws_secretsmanager.Secret(this, "bootstrappersecret", {
             secretName: [
@@ -134,5 +133,5 @@ class PgStacDatabase extends constructs_1.Construct {
 }
 exports.PgStacDatabase = PgStacDatabase;
 _a = JSII_RTTI_SYMBOL_1;
-PgStacDatabase[_a] = { fqn: "eoapi-cdk.PgStacDatabase", version: "6.1.0" };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Stack,\n  aws_rds as rds,\n  aws_ec2 as ec2,\n  aws_secretsmanager as secretsmanager,\n  aws_lambda,\n  CustomResource,\n  RemovalPolicy,\n  Duration,\n  aws_logs,\n\n} from \"aws-cdk-lib\";\nimport { Construct } from \"constructs\";\nimport { CustomLambdaFunctionProps } from \"../utils\";\n\nconst instanceSizes: Record<string, number> = require(\"./instance-memory.json\");\nconst DEFAULT_PGSTAC_VERSION = \"0.7.10\";\n\nfunction hasVpc(\n  instance: rds.DatabaseInstance | rds.IDatabaseInstance\n): instance is rds.DatabaseInstance {\n  return (instance as rds.DatabaseInstance).vpc !== undefined;\n}\n\n/**\n * An RDS instance with pgSTAC installed. This is a wrapper around the\n * `rds.DatabaseInstance` higher-level construct making use\n * of the BootstrapPgStac construct.\n */\nexport class PgStacDatabase extends Construct {\n  db: rds.DatabaseInstance;\n  pgstacSecret: secretsmanager.ISecret;\n\n  constructor(scope: Construct, id: string, props: PgStacDatabaseProps) {\n    super(scope, id);\n\n    const defaultParameters = this.getParameters(\n      props.instanceType?.toString() || \"m5.large\",\n      props.parameters\n    );\n    const parameterGroup = new rds.ParameterGroup(this, \"parameterGroup\", {\n      engine: props.engine,\n      parameters: {\n        shared_buffers: defaultParameters.sharedBuffers,\n        effective_cache_size: defaultParameters.effectiveCacheSize,\n        work_mem: defaultParameters.workMem,\n        maintenance_work_mem: defaultParameters.maintenanceWorkMem,\n        max_locks_per_transaction: defaultParameters.maxLocksPerTransaction,\n        temp_buffers: defaultParameters.tempBuffers,\n        seq_page_cost: defaultParameters.seqPageCost,\n        random_page_cost: defaultParameters.randomPageCost,\n        ...props.parameters,\n      },\n    });\n\n    this.db = new rds.DatabaseInstance(this, \"db\", {\n      instanceIdentifier: Stack.of(this).stackName,\n      parameterGroup,\n      ...props,\n    });\n\n    const handler = new aws_lambda.Function(this, \"lambda\", {\n      // defaults for configurable properties\n      runtime: aws_lambda.Runtime.PYTHON_3_11,\n      handler: \"handler.handler\",\n      memorySize: 128,\n      logRetention: aws_logs.RetentionDays.ONE_WEEK,\n      timeout: Duration.minutes(2),\n      code: aws_lambda.Code.fromDockerBuild(__dirname, {\n        file: \"bootstrapper_runtime/Dockerfile\",\n        buildArgs: {PGSTAC_VERSION: DEFAULT_PGSTAC_VERSION, PYTHON_VERSION: \"3.11\"}\n      }),\n      // overwrites defaults with user-provided configurable properties\n      ...props.bootstrapperLambdaFunctionOptions,\n      // Non configurable properties that are going to be overwritten even if provided by the user\n      vpc: hasVpc(this.db) ? this.db.vpc : props.vpc,\n      allowPublicSubnet: true\n    });\n\n    this.pgstacSecret = new secretsmanager.Secret(this, \"bootstrappersecret\", {\n      secretName: [\n        props.secretsPrefix || \"pgstac\",\n        id,\n        this.node.addr.slice(-8),\n      ].join(\"/\"),\n      generateSecretString: {\n        secretStringTemplate: JSON.stringify({\n          dbname: props.pgstacDbName || \"pgstac\",\n          engine: \"postgres\",\n          port: 5432,\n          host: this.db.instanceEndpoint.hostname,\n          username: props.pgstacUsername || \"pgstac_user\",\n        }),\n        generateStringKey: \"password\",\n        excludePunctuation: true,\n      },\n      description: `PgSTAC database bootstrapped by ${\n        Stack.of(this).stackName\n      }`,\n    });\n\n    // Allow lambda to...\n    // read new user secret\n    this.pgstacSecret.grantRead(handler);\n    // read database secret\n    this.db.secret!.grantRead(handler);\n    // connect to database\n    this.db.connections.allowFrom(handler, ec2.Port.tcp(5432));\n\n    let customResourceProperties : { [key: string]: any} = {};\n\n    // if customResourceProperties are provided, fill in the values. \n    if (props.customResourceProperties) {\n      Object.assign(customResourceProperties, props.customResourceProperties);\n    }\n\n    // update properties\n    customResourceProperties[\"conn_secret_arn\"] = this.db.secret!.secretArn;\n    customResourceProperties[\"new_user_secret_arn\"] = this.pgstacSecret.secretArn;\n\n    // if props.lambdaFunctionOptions doesn't have 'code' defined, update pgstac_version (needed for default runtime)\n    if (!props.bootstrapperLambdaFunctionOptions?.code) {\n      customResourceProperties[\"pgstac_version\"] = DEFAULT_PGSTAC_VERSION;\n    }\n    // this.connections = props.database.connections;\n    new CustomResource(this, \"bootstrapper\", {\n      serviceToken: handler.functionArn,\n      properties: customResourceProperties,\n      removalPolicy: RemovalPolicy.RETAIN, // This retains the custom resource (which doesn't really exist), not the database\n    });\n\n  }\n\n  public getParameters(\n    instanceType: string,\n    parameters: PgStacDatabaseProps[\"parameters\"]\n  ): DatabaseParameters {\n    // https://github.com/aws/aws-cli/issues/1279#issuecomment-909318236\n    const memory_in_kb = instanceSizes[instanceType] * 1024;\n\n    // It's only necessary to consider passed in parameters for any value that used to\n    // derive subsequent values. Values that don't have dependencies will be overriden\n    // when we unpack the passed-in user parameters\n    const maxConnections = parameters?.maxConnections\n      ? Number.parseInt(parameters.maxConnections)\n      : // https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Limits.html#RDS_Limits.MaxConnections\n        Math.min(Math.round((memory_in_kb * 1024) / 9531392), 5000);\n    const sharedBuffers = parameters?.sharedBufers\n      ? Number.parseInt(parameters.sharedBufers)\n      : Math.round(0.25 * memory_in_kb);\n\n    const effectiveCacheSize = Math.round(0.75 * memory_in_kb);\n    const workMem = Math.floor(sharedBuffers / maxConnections);\n    const maintenanceWorkMem = Math.round(0.25 * sharedBuffers);\n\n    const tempBuffers = 128 * 1024;\n    const seqPageCost = 1;\n    const randomPageCost = 1.1;\n\n    return {\n      maxConnections: `${maxConnections}`,\n      sharedBuffers: `${sharedBuffers / 8}`, // Represented in 8kb blocks\n      effectiveCacheSize: `${effectiveCacheSize}`,\n      workMem: `${workMem}`,\n      maintenanceWorkMem: `${maintenanceWorkMem}`,\n      maxLocksPerTransaction: \"1024\",\n      tempBuffers: `${tempBuffers}`,\n      seqPageCost: `${seqPageCost}`,\n      randomPageCost: `${randomPageCost}`,\n    };\n  }\n}\n\nexport interface PgStacDatabaseProps extends rds.DatabaseInstanceProps {\n  /**\n   * Name of database that is to be created and onto which pgSTAC will be installed.\n   *\n   * @default pgstac\n   */\n  readonly pgstacDbName?: string;\n\n    /**\n   * Prefix to assign to the generated `secrets_manager.Secret`\n   *\n   * @default pgstac\n   */\n    readonly secretsPrefix?: string;\n\n  /**\n   * Name of user that will be generated for connecting to the pgSTAC database.\n   *\n   * @default pgstac_user\n   */\n  readonly pgstacUsername?: string;\n\n  /**\n   * Lambda function Custom Resource properties. A custom resource property is going to be created\n   * to trigger the boostrapping lambda function. This parameter allows the user to specify additional properties\n   * on top of the defaults ones. \n   *\n   */\n  readonly customResourceProperties?: {\n    [key: string]: any;\n}\n\n  /**\n   * Optional settings for the bootstrapper lambda function. Can be anything that can be configured on the lambda function, but some will be overwritten by values defined here. \n   *\n   * @default - defined in the construct.\n   */\n  readonly bootstrapperLambdaFunctionOptions?: CustomLambdaFunctionProps;\n}\n\nexport interface DatabaseParameters {\n  /**\n   * @default - LEAST({DBInstanceClassMemory/9531392}, 5000)\n   */\n  readonly maxConnections: string;\n\n  /**\n   * Note: This value is measured in 8KB blocks.\n   *\n   * @default '{DBInstanceClassMemory/32768}' 25% of instance memory, ie `{(DBInstanceClassMemory/(1024*8)) * 0.25}`\n   */\n  readonly sharedBuffers: string;\n\n  /**\n   * @default - 75% of instance memory\n   */\n  readonly effectiveCacheSize: string;\n\n  /**\n   * @default - shared buffers divided by max connections\n   */\n  readonly workMem: string;\n\n  /**\n   * @default - 25% of shared buffers\n   */\n  readonly maintenanceWorkMem: string;\n\n  /**\n   * @default 1024\n   */\n  readonly maxLocksPerTransaction: string;\n\n  /**\n   * @default 131172 (128 * 1024)\n   */\n  readonly tempBuffers: string;\n\n  /**\n   * @default 1\n   */\n  readonly seqPageCost: string;\n\n  /**\n   * @default 1.1\n   */\n  readonly randomPageCost: string;\n}\n"]}
+PgStacDatabase[_a] = { fqn: "eoapi-cdk.PgStacDatabase", version: "7.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Stack,\n  aws_rds as rds,\n  aws_ec2 as ec2,\n  aws_secretsmanager as secretsmanager,\n  aws_lambda,\n  CustomResource,\n  RemovalPolicy,\n  Duration,\n  aws_logs,\n\n} from \"aws-cdk-lib\";\nimport { Construct } from \"constructs\";\nimport { CustomLambdaFunctionProps } from \"../utils\";\n\nconst instanceSizes: Record<string, number> = require(\"./instance-memory.json\");\nconst DEFAULT_PGSTAC_VERSION = \"0.7.10\";\n\nfunction hasVpc(\n  instance: rds.DatabaseInstance | rds.IDatabaseInstance\n): instance is rds.DatabaseInstance {\n  return (instance as rds.DatabaseInstance).vpc !== undefined;\n}\n\n/**\n * An RDS instance with pgSTAC installed. This is a wrapper around the\n * `rds.DatabaseInstance` higher-level construct making use\n * of the BootstrapPgStac construct.\n */\nexport class PgStacDatabase extends Construct {\n  db: rds.DatabaseInstance;\n  pgstacSecret: secretsmanager.ISecret;\n\n  constructor(scope: Construct, id: string, props: PgStacDatabaseProps) {\n    super(scope, id);\n\n    const defaultParameters = this.getParameters(\n      props.instanceType?.toString() || \"m5.large\",\n      props.parameters\n    );\n    const parameterGroup = new rds.ParameterGroup(this, \"parameterGroup\", {\n      engine: props.engine,\n      parameters: {\n        shared_buffers: defaultParameters.sharedBuffers,\n        effective_cache_size: defaultParameters.effectiveCacheSize,\n        work_mem: defaultParameters.workMem,\n        maintenance_work_mem: defaultParameters.maintenanceWorkMem,\n        max_locks_per_transaction: defaultParameters.maxLocksPerTransaction,\n        temp_buffers: defaultParameters.tempBuffers,\n        seq_page_cost: defaultParameters.seqPageCost,\n        random_page_cost: defaultParameters.randomPageCost,\n        ...props.parameters,\n      },\n    });\n\n    this.db = new rds.DatabaseInstance(this, \"db\", {\n      instanceIdentifier: Stack.of(this).stackName,\n      parameterGroup,\n      ...props,\n    });\n\n    const handler = new aws_lambda.Function(this, \"lambda\", {\n      // defaults\n      runtime: aws_lambda.Runtime.PYTHON_3_11,\n      handler: \"handler.handler\",\n      memorySize: 128,\n      logRetention: aws_logs.RetentionDays.ONE_WEEK,\n      timeout: Duration.minutes(2),\n      code: aws_lambda.Code.fromDockerBuild(__dirname, {\n        file: \"bootstrapper_runtime/Dockerfile\",\n        buildArgs: {PGSTAC_VERSION: DEFAULT_PGSTAC_VERSION, PYTHON_VERSION: \"3.11\"}\n      }),\n      vpc: hasVpc(this.db) ? this.db.vpc : props.vpc,\n      allowPublicSubnet: true,\n      // overwrites defaults with user-provided configurable properties,\n      ...props.bootstrapperLambdaFunctionOptions,\n    });\n\n    this.pgstacSecret = new secretsmanager.Secret(this, \"bootstrappersecret\", {\n      secretName: [\n        props.secretsPrefix || \"pgstac\",\n        id,\n        this.node.addr.slice(-8),\n      ].join(\"/\"),\n      generateSecretString: {\n        secretStringTemplate: JSON.stringify({\n          dbname: props.pgstacDbName || \"pgstac\",\n          engine: \"postgres\",\n          port: 5432,\n          host: this.db.instanceEndpoint.hostname,\n          username: props.pgstacUsername || \"pgstac_user\",\n        }),\n        generateStringKey: \"password\",\n        excludePunctuation: true,\n      },\n      description: `PgSTAC database bootstrapped by ${\n        Stack.of(this).stackName\n      }`,\n    });\n\n    // Allow lambda to...\n    // read new user secret\n    this.pgstacSecret.grantRead(handler);\n    // read database secret\n    this.db.secret!.grantRead(handler);\n    // connect to database\n    this.db.connections.allowFrom(handler, ec2.Port.tcp(5432));\n\n    let customResourceProperties : { [key: string]: any} = {};\n\n    // if customResourceProperties are provided, fill in the values. \n    if (props.customResourceProperties) {\n      Object.assign(customResourceProperties, props.customResourceProperties);\n    }\n\n    // update properties\n    customResourceProperties[\"conn_secret_arn\"] = this.db.secret!.secretArn;\n    customResourceProperties[\"new_user_secret_arn\"] = this.pgstacSecret.secretArn;\n\n    // if props.lambdaFunctionOptions doesn't have 'code' defined, update pgstac_version (needed for default runtime)\n    if (!props.bootstrapperLambdaFunctionOptions?.code) {\n      customResourceProperties[\"pgstac_version\"] = DEFAULT_PGSTAC_VERSION;\n    }\n    // this.connections = props.database.connections;\n    new CustomResource(this, \"bootstrapper\", {\n      serviceToken: handler.functionArn,\n      properties: customResourceProperties,\n      removalPolicy: RemovalPolicy.RETAIN, // This retains the custom resource (which doesn't really exist), not the database\n    });\n\n  }\n\n  public getParameters(\n    instanceType: string,\n    parameters: PgStacDatabaseProps[\"parameters\"]\n  ): DatabaseParameters {\n    // https://github.com/aws/aws-cli/issues/1279#issuecomment-909318236\n    const memory_in_kb = instanceSizes[instanceType] * 1024;\n\n    // It's only necessary to consider passed in parameters for any value that used to\n    // derive subsequent values. Values that don't have dependencies will be overriden\n    // when we unpack the passed-in user parameters\n    const maxConnections = parameters?.maxConnections\n      ? Number.parseInt(parameters.maxConnections)\n      : // https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Limits.html#RDS_Limits.MaxConnections\n        Math.min(Math.round((memory_in_kb * 1024) / 9531392), 5000);\n    const sharedBuffers = parameters?.sharedBufers\n      ? Number.parseInt(parameters.sharedBufers)\n      : Math.round(0.25 * memory_in_kb);\n\n    const effectiveCacheSize = Math.round(0.75 * memory_in_kb);\n    const workMem = Math.floor(sharedBuffers / maxConnections);\n    const maintenanceWorkMem = Math.round(0.25 * sharedBuffers);\n\n    const tempBuffers = 128 * 1024;\n    const seqPageCost = 1;\n    const randomPageCost = 1.1;\n\n    return {\n      maxConnections: `${maxConnections}`,\n      sharedBuffers: `${sharedBuffers / 8}`, // Represented in 8kb blocks\n      effectiveCacheSize: `${effectiveCacheSize}`,\n      workMem: `${workMem}`,\n      maintenanceWorkMem: `${maintenanceWorkMem}`,\n      maxLocksPerTransaction: \"1024\",\n      tempBuffers: `${tempBuffers}`,\n      seqPageCost: `${seqPageCost}`,\n      randomPageCost: `${randomPageCost}`,\n    };\n  }\n}\n\nexport interface PgStacDatabaseProps extends rds.DatabaseInstanceProps {\n  /**\n   * Name of database that is to be created and onto which pgSTAC will be installed.\n   *\n   * @default pgstac\n   */\n  readonly pgstacDbName?: string;\n\n    /**\n   * Prefix to assign to the generated `secrets_manager.Secret`\n   *\n   * @default pgstac\n   */\n    readonly secretsPrefix?: string;\n\n  /**\n   * Name of user that will be generated for connecting to the pgSTAC database.\n   *\n   * @default pgstac_user\n   */\n  readonly pgstacUsername?: string;\n\n  /**\n   * Lambda function Custom Resource properties. A custom resource property is going to be created\n   * to trigger the boostrapping lambda function. This parameter allows the user to specify additional properties\n   * on top of the defaults ones. \n   *\n   */\n  readonly customResourceProperties?: {\n    [key: string]: any;\n}\n\n  /**\n   * Can be used to override the default lambda function properties.\n   *\n   * @default - defined in the construct.\n   */\n  readonly bootstrapperLambdaFunctionOptions?: CustomLambdaFunctionProps;\n}\n\nexport interface DatabaseParameters {\n  /**\n   * @default - LEAST({DBInstanceClassMemory/9531392}, 5000)\n   */\n  readonly maxConnections: string;\n\n  /**\n   * Note: This value is measured in 8KB blocks.\n   *\n   * @default '{DBInstanceClassMemory/32768}' 25% of instance memory, ie `{(DBInstanceClassMemory/(1024*8)) * 0.25}`\n   */\n  readonly sharedBuffers: string;\n\n  /**\n   * @default - 75% of instance memory\n   */\n  readonly effectiveCacheSize: string;\n\n  /**\n   * @default - shared buffers divided by max connections\n   */\n  readonly workMem: string;\n\n  /**\n   * @default - 25% of shared buffers\n   */\n  readonly maintenanceWorkMem: string;\n\n  /**\n   * @default 1024\n   */\n  readonly maxLocksPerTransaction: string;\n\n  /**\n   * @default 131172 (128 * 1024)\n   */\n  readonly tempBuffers: string;\n\n  /**\n   * @default 1\n   */\n  readonly seqPageCost: string;\n\n  /**\n   * @default 1.1\n   */\n  readonly randomPageCost: string;\n}\n"]}

package/lib/ingestor-api/index.d.ts

@@ -57,13 +57,13 @@ export interface StacIngestorProps {
      */
     readonly ingestorDomainNameOptions?: apigateway.DomainNameOptions;
     /**
-       * Optional settings for the lambda function. Can be anything that can be configured on the lambda function, but some will be overwritten by values defined here.
+       * Can be used to override the default lambda function properties.
        *
        * @default - default settings are defined in the construct.
        */
     readonly apiLambdaFunctionOptions?: CustomLambdaFunctionProps;
     /**
-       * Optional settings for the lambda function. Can be anything that can be configured on the lambda function, but some will be overwritten by values defined here.
+       * Can be used to override the default lambda function properties.
        *
        * @default - default settings are defined in the construct.
        */