eoapi-cdk 5.0.0

package/lib/bootstrapper/runtime/handler.py

@@ -0,0 +1,235 @@
+"""
+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
+import psycopg
+import httpx
+from psycopg import sql
+from psycopg.conninfo import make_conninfo
+from pypgstac.db import PgstacDB
+from pypgstac.migrate import Migrate
+
+
+def send(
+    event,
+    context,
+    responseStatus,
+    responseData,
+    physicalResourceId=None,
+    noEcho=False,
+):
+    """
+    Copyright 2016 Amazon Web Services, Inc. or its affiliates. All Rights Reserved.
+    This file is licensed to you under the AWS Customer Agreement (the "License").
+    You may not use this file except in compliance with the License.
+    A copy of the License is located at http://aws.amazon.com/agreement/ .
+    This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, express or implied.
+    See the License for the specific language governing permissions and limitations under the License.
+
+    Send response from AWS Lambda.
+
+    Note: The cfnresponse module is available only when you use the ZipFile property to write your source code.
+    It isn't available for source code that's stored in Amazon S3 buckets.
+    For code in buckets, you must write your own functions to send responses.
+    """
+    responseUrl = event["ResponseURL"]
+
+    print(responseUrl)
+
+    responseBody = {}
+    responseBody["Status"] = responseStatus
+    responseBody["Reason"] = (
+        "See the details in CloudWatch Log Stream: " + context.log_stream_name
+    )
+    responseBody["PhysicalResourceId"] = physicalResourceId or context.log_stream_name
+    responseBody["StackId"] = event["StackId"]
+    responseBody["RequestId"] = event["RequestId"]
+    responseBody["LogicalResourceId"] = event["LogicalResourceId"]
+    responseBody["NoEcho"] = noEcho
+    responseBody["Data"] = responseData
+
+    json_responseBody = json.dumps(responseBody)
+
+    print("Response body:\n" + json_responseBody)
+
+    headers = {"content-type": "", "content-length": str(len(json_responseBody))}
+
+    try:
+        response = httpx.put(responseUrl, data=json_responseBody, headers=headers)
+        print("Status code: " + response.reason)
+    except Exception as e:
+        print("send(..) failed executing httpx.put(..): " + str(e))
+
+
+def get_secret(secret_name):
+    """Get Secrets from secret manager."""
+    print(f"Fetching {secret_name}")
+    client = boto3.client(service_name="secretsmanager")
+    response = client.get_secret_value(SecretId=secret_name)
+    return json.loads(response["SecretString"])
+
+
+def create_db(cursor, db_name: str) -> None:
+    """Create DB."""
+    cursor.execute(
+        sql.SQL("SELECT 1 FROM pg_catalog.pg_database " "WHERE datname = %s"), [db_name]
+    )
+    if cursor.fetchone():
+        print(f"database {db_name} exists, not creating DB")
+    else:
+        print(f"database {db_name} not found, creating...")
+        cursor.execute(
+            sql.SQL("CREATE DATABASE {db_name}").format(db_name=sql.Identifier(db_name))
+        )
+
+
+def create_user(cursor, username: str, password: str) -> None:
+    """Create User."""
+    cursor.execute(
+        sql.SQL(
+            "DO $$ "
+            "BEGIN "
+            "  IF NOT EXISTS ( "
+            "       SELECT 1 FROM pg_roles "
+            "       WHERE rolname = {user}) "
+            "  THEN "
+            "    CREATE USER {username} "
+            "    WITH PASSWORD {password}; "
+            "  ELSE "
+            "    ALTER USER {username} "
+            "    WITH PASSWORD {password}; "
+            "  END IF; "
+            "END "
+            "$$; "
+        ).format(username=sql.Identifier(username), password=password, user=username)
+    )
+
+
+def create_permissions(cursor, db_name: str, username: str) -> None:
+    """Add permissions."""
+    cursor.execute(
+        sql.SQL(
+            "GRANT CONNECT ON DATABASE {db_name} TO {username};"
+            "GRANT CREATE ON DATABASE {db_name} TO {username};"  # Allow schema creation
+            "GRANT USAGE ON SCHEMA public TO {username};"
+            "ALTER DEFAULT PRIVILEGES IN SCHEMA public "
+            "GRANT ALL PRIVILEGES ON TABLES TO {username};"
+            "ALTER DEFAULT PRIVILEGES IN SCHEMA public "
+            "GRANT ALL PRIVILEGES ON SEQUENCES TO {username};"
+            "GRANT pgstac_read TO {username};"
+            "GRANT pgstac_ingest TO {username};"
+            "GRANT pgstac_admin TO {username};"
+        ).format(
+            db_name=sql.Identifier(db_name),
+            username=sql.Identifier(username),
+        )
+    )
+
+
+def register_extensions(cursor) -> None:
+    """Add PostGIS extension."""
+    cursor.execute(sql.SQL("CREATE EXTENSION IF NOT EXISTS postgis;"))
+
+
+def handler(event, context):
+    """Lambda Handler."""
+    print(f"Handling {event}")
+
+    if event["RequestType"] not in ["Create", "Update"]:
+        return send(event, context, "SUCCESS", {"msg": "No action to be taken"})
+
+    try:
+        params = event["ResourceProperties"]
+        connection_params = get_secret(params["conn_secret_arn"])
+        user_params = get_secret(params["new_user_secret_arn"])
+
+        print("Connecting to admin DB...")
+        admin_db_conninfo = make_conninfo(
+            dbname=connection_params.get("dbname", "postgres"),
+            user=connection_params["username"],
+            password=connection_params["password"],
+            host=connection_params["host"],
+            port=connection_params["port"],
+        )
+        with psycopg.connect(admin_db_conninfo, autocommit=True) as conn:
+            with conn.cursor() as cur:
+                print("Creating database...")
+                create_db(
+                    cursor=cur,
+                    db_name=user_params["dbname"],
+                )
+
+                print("Creating user...")
+                create_user(
+                    cursor=cur,
+                    username=user_params["username"],
+                    password=user_params["password"],
+                )
+
+        # Install extensions on the user DB with
+        # superuser permissions, since they will
+        # otherwise fail to install when run as
+        # the non-superuser within the pgstac
+        # migrations.
+        print("Connecting to STAC DB...")
+        stac_db_conninfo = make_conninfo(
+            dbname=user_params["dbname"],
+            user=connection_params["username"],
+            password=connection_params["password"],
+            host=connection_params["host"],
+            port=connection_params["port"],
+        )
+        with psycopg.connect(stac_db_conninfo, autocommit=True) as conn:
+            with conn.cursor() as cur:
+                print("Registering PostGIS ...")
+                register_extensions(cursor=cur)
+
+        stac_db_admin_dsn = (
+            "postgresql://{user}:{password}@{host}:{port}/{dbname}".format(
+                dbname=user_params.get("dbname", "postgres"),
+                user=connection_params["username"],
+                password=connection_params["password"],
+                host=connection_params["host"],
+                port=connection_params["port"],
+            )
+        )
+
+        pgdb = PgstacDB(dsn=stac_db_admin_dsn, debug=True)
+        print(f"Current {pgdb.version=}")
+
+        # As admin, run migrations
+        print("Running migrations...")
+        Migrate(pgdb).run_migration(params["pgstac_version"])
+
+        # Assign appropriate permissions to user (requires pgSTAC migrations to have run)
+        with psycopg.connect(admin_db_conninfo, autocommit=True) as conn:
+            with conn.cursor() as cur:
+                print("Setting permissions...")
+                create_permissions(
+                    cursor=cur,
+                    db_name=user_params["dbname"],
+                    username=user_params["username"],
+                )
+
+        print("Adding mosaic index...")
+        with psycopg.connect(
+            stac_db_admin_dsn,
+            autocommit=True,
+            options="-c search_path=pgstac,public -c application_name=pgstac",
+        ) as conn:
+            conn.execute(
+                sql.SQL(
+                    "CREATE INDEX IF NOT EXISTS searches_mosaic ON searches ((true)) WHERE metadata->>'type'='mosaic';"
+                )
+            )
+
+    except Exception as e:
+        print(f"Unable to bootstrap database with exception={e}")
+        send(event, context, "FAILED", {"message": str(e)})
+        raise e
+
+    print("Complete.")
+    return send(event, context, "SUCCESS", {})

package/lib/database/index.d.ts

@@ -0,0 +1,60 @@
+import { aws_rds as rds, aws_secretsmanager as secretsmanager } from "aws-cdk-lib";
+import { Construct } from "constructs";
+import { BootstrapPgStacProps } from "../bootstrapper";
+/**
+ * An RDS instance with pgSTAC installed. This is a wrapper around the
+ * `rds.DatabaseInstance` higher-level construct making use
+ * of the BootstrapPgStac construct.
+ */
+export declare class PgStacDatabase extends Construct {
+    db: rds.DatabaseInstance;
+    pgstacSecret: secretsmanager.ISecret;
+    constructor(scope: Construct, id: string, props: PgStacDatabaseProps);
+    getParameters(instanceType: string, parameters: PgStacDatabaseProps["parameters"]): DatabaseParameters;
+}
+export interface PgStacDatabaseProps extends rds.DatabaseInstanceProps {
+    readonly pgstacDbName?: BootstrapPgStacProps["pgstacDbName"];
+    readonly pgstacVersion?: BootstrapPgStacProps["pgstacVersion"];
+    readonly pgstacUsername?: BootstrapPgStacProps["pgstacUsername"];
+    readonly secretsPrefix?: BootstrapPgStacProps["secretsPrefix"];
+}
+export interface DatabaseParameters {
+    /**
+     * @default - LEAST({DBInstanceClassMemory/9531392}, 5000)
+     */
+    readonly maxConnections: string;
+    /**
+     * Note: This value is measured in 8KB blocks.
+     *
+     * @default '{DBInstanceClassMemory/32768}' 25% of instance memory, ie `{(DBInstanceClassMemory/(1024*8)) * 0.25}`
+     */
+    readonly sharedBuffers: string;
+    /**
+     * @default - 75% of instance memory
+     */
+    readonly effectiveCacheSize: string;
+    /**
+     * @default - shared buffers divided by max connections
+     */
+    readonly workMem: string;
+    /**
+     * @default - 25% of shared buffers
+     */
+    readonly maintenanceWorkMem: string;
+    /**
+     * @default 1024
+     */
+    readonly maxLocksPerTransaction: string;
+    /**
+     * @default 131172 (128 * 1024)
+     */
+    readonly tempBuffers: string;
+    /**
+     * @default 1
+     */
+    readonly seqPageCost: string;
+    /**
+     * @default 1.1
+     */
+    readonly randomPageCost: string;
+}

package/lib/database/index.js

@@ -0,0 +1,84 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgStacDatabase = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const constructs_1 = require("constructs");
+const bootstrapper_1 = require("../bootstrapper");
+const instanceSizes = require("./instance-memory.json");
+/**
+ * An RDS instance with pgSTAC installed. This is a wrapper around the
+ * `rds.DatabaseInstance` higher-level construct making use
+ * of the BootstrapPgStac construct.
+ */
+class PgStacDatabase extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const defaultParameters = this.getParameters(props.instanceType?.toString() || "m5.large", props.parameters);
+        const parameterGroup = new aws_cdk_lib_1.aws_rds.ParameterGroup(this, "parameterGroup", {
+            engine: props.engine,
+            parameters: {
+                shared_buffers: defaultParameters.sharedBuffers,
+                effective_cache_size: defaultParameters.effectiveCacheSize,
+                work_mem: defaultParameters.workMem,
+                maintenance_work_mem: defaultParameters.maintenanceWorkMem,
+                max_locks_per_transaction: defaultParameters.maxLocksPerTransaction,
+                temp_buffers: defaultParameters.tempBuffers,
+                seq_page_cost: defaultParameters.seqPageCost,
+                random_page_cost: defaultParameters.randomPageCost,
+                ...props.parameters,
+            },
+        });
+        this.db = new aws_cdk_lib_1.aws_rds.DatabaseInstance(this, "db", {
+            instanceIdentifier: aws_cdk_lib_1.Stack.of(this).stackName,
+            parameterGroup,
+            ...props,
+        });
+        const bootstrap = new bootstrapper_1.BootstrapPgStac(this, "bootstrap-pgstac-instance", {
+            vpc: props.vpc,
+            database: this.db,
+            dbSecret: this.db.secret,
+            pgstacDbName: props.pgstacDbName,
+            pgstacVersion: props.pgstacVersion,
+            pgstacUsername: props.pgstacUsername,
+            secretsPrefix: props.secretsPrefix,
+        });
+        this.pgstacSecret = bootstrap.secret;
+    }
+    getParameters(instanceType, parameters) {
+        // https://github.com/aws/aws-cli/issues/1279#issuecomment-909318236
+        const memory_in_kb = instanceSizes[instanceType] * 1024;
+        // It's only necessary to consider passed in parameters for any value that used to
+        // derive subsequent values. Values that don't have dependencies will be overriden
+        // when we unpack the passed-in user parameters
+        const maxConnections = parameters?.maxConnections
+            ? Number.parseInt(parameters.maxConnections)
+            : // https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_Limits.html#RDS_Limits.MaxConnections
+                Math.min(Math.round((memory_in_kb * 1024) / 9531392), 5000);
+        const sharedBuffers = parameters?.sharedBufers
+            ? Number.parseInt(parameters.sharedBufers)
+            : Math.round(0.25 * memory_in_kb);
+        const effectiveCacheSize = Math.round(0.75 * memory_in_kb);
+        const workMem = Math.floor(sharedBuffers / maxConnections);
+        const maintenanceWorkMem = Math.round(0.25 * sharedBuffers);
+        const tempBuffers = 128 * 1024;
+        const seqPageCost = 1;
+        const randomPageCost = 1.1;
+        return {
+            maxConnections: `${maxConnections}`,
+            sharedBuffers: `${sharedBuffers / 8}`,
+            effectiveCacheSize: `${effectiveCacheSize}`,
+            workMem: `${workMem}`,
+            maintenanceWorkMem: `${maintenanceWorkMem}`,
+            maxLocksPerTransaction: "1024",
+            tempBuffers: `${tempBuffers}`,
+            seqPageCost: `${seqPageCost}`,
+            randomPageCost: `${randomPageCost}`,
+        };
+    }
+}
+exports.PgStacDatabase = PgStacDatabase;
+_a = JSII_RTTI_SYMBOL_1;
+PgStacDatabase[_a] = { fqn: "eoapi-cdk.PgStacDatabase", version: "5.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_secretsmanager as secretsmanager,\n} from \"aws-cdk-lib\";\nimport { Construct } from \"constructs\";\nimport { BootstrapPgStac, BootstrapPgStacProps } from \"../bootstrapper\";\n\nconst instanceSizes: Record<string, number> = require(\"./instance-memory.json\");\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 bootstrap = new BootstrapPgStac(this, \"bootstrap-pgstac-instance\", {\n      vpc: props.vpc,\n      database: this.db,\n      dbSecret: this.db.secret!,\n      pgstacDbName: props.pgstacDbName,\n      pgstacVersion: props.pgstacVersion,\n      pgstacUsername: props.pgstacUsername,\n      secretsPrefix: props.secretsPrefix,\n    });\n\n    this.pgstacSecret = bootstrap.secret;\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  readonly pgstacDbName?: BootstrapPgStacProps[\"pgstacDbName\"];\n  readonly pgstacVersion?: BootstrapPgStacProps[\"pgstacVersion\"];\n  readonly pgstacUsername?: BootstrapPgStacProps[\"pgstacUsername\"];\n  readonly secretsPrefix?: BootstrapPgStacProps[\"secretsPrefix\"];\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"]}