eoapi-cdk 5.0.0

package/lib/ingestor-api/index.js

@@ -0,0 +1,147 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StacIngestor = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_lambda_python_alpha_1 = require("@aws-cdk/aws-lambda-python-alpha");
+const constructs_1 = require("constructs");
+class StacIngestor extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.table = this.buildTable();
+        const env = {
+            DYNAMODB_TABLE: this.table.tableName,
+            ROOT_PATH: `/${props.stage}`,
+            NO_PYDANTIC_SSM_SETTINGS: "1",
+            STAC_URL: props.stacUrl,
+            DATA_ACCESS_ROLE: props.dataAccessRole.roleArn,
+            ...props.apiEnv,
+        };
+        this.handlerRole = new aws_cdk_lib_1.aws_iam.Role(this, "execution-role", {
+            description: "Role used by STAC Ingestor. Manually defined so that we can choose a name that is supported by the data access roles trust policy",
+            assumedBy: new aws_cdk_lib_1.aws_iam.ServicePrincipal("lambda.amazonaws.com"),
+            managedPolicies: [
+                aws_cdk_lib_1.aws_iam.ManagedPolicy.fromAwsManagedPolicyName("service-role/AWSLambdaBasicExecutionRole"),
+                aws_cdk_lib_1.aws_iam.ManagedPolicy.fromAwsManagedPolicyName("service-role/AWSLambdaVPCAccessExecutionRole"),
+            ],
+        });
+        const handler = this.buildApiLambda({
+            table: this.table,
+            env,
+            dataAccessRole: props.dataAccessRole,
+            stage: props.stage,
+            dbSecret: props.stacDbSecret,
+            dbVpc: props.vpc,
+            dbSecurityGroup: props.stacDbSecurityGroup,
+            subnetSelection: props.subnetSelection,
+        });
+        this.buildApiEndpoint({
+            handler,
+            stage: props.stage,
+            endpointConfiguration: props.apiEndpointConfiguration,
+            policy: props.apiPolicy,
+        });
+        this.buildIngestor({
+            table: this.table,
+            env: env,
+            dbSecret: props.stacDbSecret,
+            dbVpc: props.vpc,
+            dbSecurityGroup: props.stacDbSecurityGroup,
+            subnetSelection: props.subnetSelection,
+        });
+        this.registerSsmParameter({
+            name: "dynamodb_table",
+            value: this.table.tableName,
+            description: "Name of table used to store ingestions",
+        });
+    }
+    buildTable() {
+        const table = new aws_cdk_lib_1.aws_dynamodb.Table(this, "ingestions-table", {
+            partitionKey: { name: "created_by", type: aws_cdk_lib_1.aws_dynamodb.AttributeType.STRING },
+            sortKey: { name: "id", type: aws_cdk_lib_1.aws_dynamodb.AttributeType.STRING },
+            billingMode: aws_cdk_lib_1.aws_dynamodb.BillingMode.PAY_PER_REQUEST,
+            removalPolicy: aws_cdk_lib_1.RemovalPolicy.DESTROY,
+            stream: aws_cdk_lib_1.aws_dynamodb.StreamViewType.NEW_IMAGE,
+        });
+        table.addGlobalSecondaryIndex({
+            indexName: "status",
+            partitionKey: { name: "status", type: aws_cdk_lib_1.aws_dynamodb.AttributeType.STRING },
+            sortKey: { name: "created_at", type: aws_cdk_lib_1.aws_dynamodb.AttributeType.STRING },
+        });
+        return table;
+    }
+    buildApiLambda(props) {
+        const handler = new aws_lambda_python_alpha_1.PythonFunction(this, "api-handler", {
+            entry: `${__dirname}/runtime`,
+            index: "src/handler.py",
+            runtime: aws_cdk_lib_1.aws_lambda.Runtime.PYTHON_3_9,
+            timeout: aws_cdk_lib_1.Duration.seconds(30),
+            environment: { DB_SECRET_ARN: props.dbSecret.secretArn, ...props.env },
+            vpc: props.dbVpc,
+            vpcSubnets: props.subnetSelection,
+            allowPublicSubnet: true,
+            role: this.handlerRole,
+            memorySize: 2048,
+        });
+        // Allow handler to read DB secret
+        props.dbSecret.grantRead(handler);
+        // Allow handler to connect to DB
+        props.dbSecurityGroup.addIngressRule(handler.connections.securityGroups[0], aws_cdk_lib_1.aws_ec2.Port.tcp(5432), "Allow connections from STAC Ingestor");
+        props.table.grantReadWriteData(handler);
+        return handler;
+    }
+    buildIngestor(props) {
+        const handler = new aws_lambda_python_alpha_1.PythonFunction(this, "stac-ingestor", {
+            entry: `${__dirname}/runtime`,
+            index: "src/ingestor.py",
+            runtime: aws_cdk_lib_1.aws_lambda.Runtime.PYTHON_3_9,
+            timeout: aws_cdk_lib_1.Duration.seconds(180),
+            environment: { DB_SECRET_ARN: props.dbSecret.secretArn, ...props.env },
+            vpc: props.dbVpc,
+            vpcSubnets: props.subnetSelection,
+            allowPublicSubnet: true,
+            memorySize: 2048,
+        });
+        // Allow handler to read DB secret
+        props.dbSecret.grantRead(handler);
+        // Allow handler to connect to DB
+        props.dbSecurityGroup.addIngressRule(handler.connections.securityGroups[0], aws_cdk_lib_1.aws_ec2.Port.tcp(5432), "Allow connections from STAC Ingestor");
+        // Allow handler to write results back to DBƒ
+        props.table.grantWriteData(handler);
+        // Trigger handler from writes to DynamoDB table
+        handler.addEventSource(new aws_cdk_lib_1.aws_lambda_event_sources.DynamoEventSource(props.table, {
+            // Read when batches reach size...
+            batchSize: 1000,
+            // ... or when window is reached.
+            maxBatchingWindow: aws_cdk_lib_1.Duration.seconds(10),
+            // Read oldest data first.
+            startingPosition: aws_cdk_lib_1.aws_lambda.StartingPosition.TRIM_HORIZON,
+            retryAttempts: 1,
+        }));
+        return handler;
+    }
+    buildApiEndpoint(props) {
+        return new aws_cdk_lib_1.aws_apigateway.LambdaRestApi(this, `${aws_cdk_lib_1.Stack.of(this).stackName}-ingestor-api`, {
+            handler: props.handler,
+            proxy: true,
+            cloudWatchRole: true,
+            deployOptions: { stageName: props.stage },
+            endpointExportName: `${aws_cdk_lib_1.Stack.of(this)}-ingestor-api`,
+            endpointConfiguration: props.endpointConfiguration,
+            policy: props.policy,
+        });
+    }
+    registerSsmParameter(props) {
+        const parameterNamespace = aws_cdk_lib_1.Stack.of(this).stackName;
+        return new aws_cdk_lib_1.aws_ssm.StringParameter(this, `${props.name.replace("_", "-")}-parameter`, {
+            description: props.description,
+            parameterName: `/${parameterNamespace}/${props.name}`,
+            stringValue: props.value,
+        });
+    }
+}
+exports.StacIngestor = StacIngestor;
+_a = JSII_RTTI_SYMBOL_1;
+StacIngestor[_a] = { fqn: "eoapi-cdk.StacIngestor", 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  aws_apigateway as apigateway,\n  aws_dynamodb as dynamodb,\n  aws_ec2 as ec2,\n  aws_iam as iam,\n  aws_lambda as lambda,\n  aws_lambda_event_sources as events,\n  aws_secretsmanager as secretsmanager,\n  aws_ssm as ssm,\n  Duration,\n  RemovalPolicy,\n  Stack,\n} from \"aws-cdk-lib\";\nimport { PythonFunction } from \"@aws-cdk/aws-lambda-python-alpha\";\nimport { Construct } from \"constructs\";\n\nexport class StacIngestor extends Construct {\n  table: dynamodb.Table;\n  public handlerRole: iam.Role;\n\n  constructor(scope: Construct, id: string, props: StacIngestorProps) {\n    super(scope, id);\n\n    this.table = this.buildTable();\n\n    const env: Record<string, string> = {\n      DYNAMODB_TABLE: this.table.tableName,\n      ROOT_PATH: `/${props.stage}`,\n      NO_PYDANTIC_SSM_SETTINGS: \"1\",\n      STAC_URL: props.stacUrl,\n      DATA_ACCESS_ROLE: props.dataAccessRole.roleArn,\n      ...props.apiEnv,\n    };\n\n    this.handlerRole = new iam.Role(this, \"execution-role\", {\n      description:\n        \"Role used by STAC Ingestor. Manually defined so that we can choose a name that is supported by the data access roles trust policy\",\n      assumedBy: new iam.ServicePrincipal(\"lambda.amazonaws.com\"),\n      managedPolicies: [\n        iam.ManagedPolicy.fromAwsManagedPolicyName(\n          \"service-role/AWSLambdaBasicExecutionRole\",\n        ),\n        iam.ManagedPolicy.fromAwsManagedPolicyName(\n          \"service-role/AWSLambdaVPCAccessExecutionRole\",\n        ),\n      ],\n    });\n    \n    const handler = this.buildApiLambda({\n      table: this.table,\n      env,\n      dataAccessRole: props.dataAccessRole,\n      stage: props.stage,\n      dbSecret: props.stacDbSecret,\n      dbVpc: props.vpc,\n      dbSecurityGroup: props.stacDbSecurityGroup,\n      subnetSelection: props.subnetSelection,\n    });\n\n    this.buildApiEndpoint({\n      handler,\n      stage: props.stage,\n      endpointConfiguration: props.apiEndpointConfiguration,\n      policy: props.apiPolicy,\n    });\n\n    this.buildIngestor({\n      table: this.table,\n      env: env,\n      dbSecret: props.stacDbSecret,\n      dbVpc: props.vpc,\n      dbSecurityGroup: props.stacDbSecurityGroup,\n      subnetSelection: props.subnetSelection,\n    });\n\n    this.registerSsmParameter({\n      name: \"dynamodb_table\",\n      value: this.table.tableName,\n      description: \"Name of table used to store ingestions\",\n    });\n  }\n\n  private buildTable(): dynamodb.Table {\n    const table = new dynamodb.Table(this, \"ingestions-table\", {\n      partitionKey: { name: \"created_by\", type: dynamodb.AttributeType.STRING },\n      sortKey: { name: \"id\", type: dynamodb.AttributeType.STRING },\n      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,\n      removalPolicy: RemovalPolicy.DESTROY,\n      stream: dynamodb.StreamViewType.NEW_IMAGE,\n    });\n\n    table.addGlobalSecondaryIndex({\n      indexName: \"status\",\n      partitionKey: { name: \"status\", type: dynamodb.AttributeType.STRING },\n      sortKey: { name: \"created_at\", type: dynamodb.AttributeType.STRING },\n    });\n\n    return table;\n  }\n\n  private buildApiLambda(props: {\n    table: dynamodb.ITable;\n    env: Record<string, string>;\n    dataAccessRole: iam.IRole;\n    stage: string;\n    dbSecret: secretsmanager.ISecret;\n    dbVpc: ec2.IVpc;\n    dbSecurityGroup: ec2.ISecurityGroup;\n    subnetSelection: ec2.SubnetSelection\n  }): PythonFunction {\n    \n    const handler = new PythonFunction(this, \"api-handler\", {\n      entry: `${__dirname}/runtime`,\n      index: \"src/handler.py\",\n      runtime: lambda.Runtime.PYTHON_3_9,\n      timeout: Duration.seconds(30),\n      environment: { DB_SECRET_ARN: props.dbSecret.secretArn, ...props.env },\n      vpc: props.dbVpc,\n      vpcSubnets: props.subnetSelection,\n      allowPublicSubnet: true,\n      role: this.handlerRole,\n      memorySize: 2048,\n    });\n\n    // Allow handler to read DB secret\n    props.dbSecret.grantRead(handler);\n\n    // Allow handler to connect to DB\n    props.dbSecurityGroup.addIngressRule(\n      handler.connections.securityGroups[0],\n      ec2.Port.tcp(5432),\n      \"Allow connections from STAC Ingestor\"\n    );\n\n    props.table.grantReadWriteData(handler);\n\n    return handler;\n  }\n\n  private buildIngestor(props: {\n    table: dynamodb.ITable;\n    env: Record<string, string>;\n    dbSecret: secretsmanager.ISecret;\n    dbVpc: ec2.IVpc;\n    dbSecurityGroup: ec2.ISecurityGroup;\n    subnetSelection: ec2.SubnetSelection;\n  }): PythonFunction {\n    const handler = new PythonFunction(this, \"stac-ingestor\", {\n      entry: `${__dirname}/runtime`,\n      index: \"src/ingestor.py\",\n      runtime: lambda.Runtime.PYTHON_3_9,\n      timeout: Duration.seconds(180),\n      environment: { DB_SECRET_ARN: props.dbSecret.secretArn, ...props.env },\n      vpc: props.dbVpc,\n      vpcSubnets: props.subnetSelection,\n      allowPublicSubnet: true,\n      memorySize: 2048,\n    });\n\n    // Allow handler to read DB secret\n    props.dbSecret.grantRead(handler);\n\n    // Allow handler to connect to DB\n    props.dbSecurityGroup.addIngressRule(\n      handler.connections.securityGroups[0],\n      ec2.Port.tcp(5432),\n      \"Allow connections from STAC Ingestor\"\n    );\n\n    // Allow handler to write results back to DBƒ\n    props.table.grantWriteData(handler);\n\n    // Trigger handler from writes to DynamoDB table\n    handler.addEventSource(\n      new events.DynamoEventSource(props.table, {\n        // Read when batches reach size...\n        batchSize: 1000,\n        // ... or when window is reached.\n        maxBatchingWindow: Duration.seconds(10),\n        // Read oldest data first.\n        startingPosition: lambda.StartingPosition.TRIM_HORIZON,\n        retryAttempts: 1,\n      })\n    );\n\n    return handler;\n  }\n\n  private buildApiEndpoint(props: {\n    handler: lambda.IFunction;\n    stage: string;\n    policy?: iam.PolicyDocument;\n    endpointConfiguration?: apigateway.EndpointConfiguration;\n  }): apigateway.LambdaRestApi {\n    return new apigateway.LambdaRestApi(\n      this,\n      `${Stack.of(this).stackName}-ingestor-api`,\n      {\n        handler: props.handler,\n        proxy: true,\n\n        cloudWatchRole: true,\n        deployOptions: { stageName: props.stage },\n        endpointExportName: `${Stack.of(this)}-ingestor-api`,\n\n        endpointConfiguration: props.endpointConfiguration,\n        policy: props.policy,\n      }\n    );\n  }\n\n  private registerSsmParameter(props: {\n    name: string;\n    value: string;\n    description: string;\n  }): ssm.IStringParameter {\n    const parameterNamespace = Stack.of(this).stackName;\n    return new ssm.StringParameter(\n      this,\n      `${props.name.replace(\"_\", \"-\")}-parameter`,\n      {\n        description: props.description,\n        parameterName: `/${parameterNamespace}/${props.name}`,\n        stringValue: props.value,\n      }\n    );\n  }\n}\n\nexport interface StacIngestorProps {\n  /**\n   * ARN of AWS Role used to validate access to S3 data\n   */\n  readonly dataAccessRole: iam.IRole;\n\n  /**\n   * URL of STAC API\n   */\n  readonly stacUrl: string;\n\n  /**\n   * Stage of deployment (e.g. `dev`, `prod`)\n   */\n  readonly stage: string;\n\n  /**\n   * Secret containing pgSTAC DB connection information\n   */\n  readonly stacDbSecret: secretsmanager.ISecret;\n\n  /**\n   * VPC running pgSTAC DB\n   */\n  readonly vpc: ec2.IVpc;\n\n  /**\n   * Security Group used by pgSTAC DB\n   */\n  readonly stacDbSecurityGroup: ec2.ISecurityGroup;\n\n  /**\n   * Boolean indicating whether or not pgSTAC DB is in a public subnet\n   */\n  readonly subnetSelection: ec2.SubnetSelection;\n\n  /**\n   * Environment variables to be sent to Lambda.\n   */\n  readonly apiEnv?: Record<string, string>;\n\n  /**\n   * API Endpoint Configuration, useful for creating private APIs.\n   */\n  readonly apiEndpointConfiguration?: apigateway.EndpointConfiguration;\n\n  /**\n   * API Policy Document, useful for creating private APIs.\n   */\n  readonly apiPolicy?: iam.PolicyDocument;\n}\n"]}

package/lib/ingestor-api/runtime/dev_requirements.txt

@@ -0,0 +1,2 @@
+httpx
+moto[dynamodb, ssm]>=4.0.9

package/lib/ingestor-api/runtime/requirements.txt

@@ -0,0 +1,12 @@
+Authlib==1.0.1
+cachetools==5.1.0
+fastapi>=0.75.1
+mangum>=0.15.0
+orjson>=3.6.8
+psycopg[binary,pool]>=3.0.15
+pydantic_ssm_settings>=0.2.0
+pydantic>=1.9.0
+pypgstac==0.6.13
+requests>=2.27.1
+# Waiting for https://github.com/stac-utils/stac-pydantic/pull/116
+stac-pydantic @ git+https://github.com/alukach/stac-pydantic.git@patch-1

package/lib/ingestor-api/runtime/src/collection.py

@@ -0,0 +1,36 @@
+import os
+
+from pypgstac.db import PgstacDB
+from pypgstac.load import Methods
+
+from .loader import Loader
+from .schemas import StacCollection
+from .utils import get_db_credentials
+
+
+def ingest(collection: StacCollection):
+    """
+    Takes a collection model,
+    does necessary preprocessing,
+    and loads into the PgSTAC collection table
+    """
+    try:
+        creds = get_db_credentials(os.environ["DB_SECRET_ARN"])
+        with PgstacDB(dsn=creds.dsn_string, debug=True) as db:
+            loader = Loader(db=db)
+            collection = [
+                collection.to_dict()
+            ]  # pypgstac wants either a string or an Iterable of dicts.
+            loader.load_collections(file=collection, insert_mode=Methods.upsert)
+    except Exception as e:
+        print(f"Encountered failure loading collection into pgSTAC: {e}")
+
+
+def delete(collection_id: str):
+    """
+    Deletes the collection from the database
+    """
+    creds = get_db_credentials(os.environ["DB_SECRET_ARN"])
+    with PgstacDB(dsn=creds.dsn_string, debug=True) as db:
+        loader = Loader(db=db)
+        loader.delete_collection(collection_id)

package/lib/ingestor-api/runtime/src/config.py

@@ -0,0 +1,46 @@
+import os
+from getpass import getuser
+from typing import Optional
+
+from pydantic import AnyHttpUrl, BaseSettings, Field, constr
+from pydantic_ssm_settings import AwsSsmSourceConfig
+
+AwsArn = constr(regex=r"^arn:aws:iam::\d{12}:role/.+")
+
+
+class Settings(BaseSettings):
+    dynamodb_table: str
+
+    root_path: Optional[str] = Field(description="Path from where to serve this URL.")
+
+    jwks_url: Optional[AnyHttpUrl] = Field(
+        description="URL of JWKS, e.g. https://cognito-idp.{region}.amazonaws.com/{userpool_id}/.well-known/jwks.json"  # noqa
+    )
+
+    stac_url: AnyHttpUrl = Field(description="URL of STAC API")
+
+    data_access_role: AwsArn = Field(
+        description="ARN of AWS Role used to validate access to S3 data"
+    )
+
+    requester_pays: Optional[bool] = Field(
+        description="Path from where to serve this URL.", default=False
+    )
+
+    class Config(AwsSsmSourceConfig):
+        env_file = ".env"
+
+    @classmethod
+    def from_ssm(cls, stack: str):
+        return cls(_secrets_dir=f"/{stack}")
+
+
+settings = (
+    Settings()
+    if os.environ.get("NO_PYDANTIC_SSM_SETTINGS")
+    else Settings.from_ssm(
+        stack=os.environ.get(
+            "STACK", f"veda-stac-ingestion-system-{os.environ.get('STAGE', getuser())}"
+        ),
+    )
+)

package/lib/ingestor-api/runtime/src/dependencies.py

@@ -0,0 +1,94 @@
+import logging
+from typing import Optional
+
+import boto3
+import requests
+from authlib.jose import JsonWebKey, JsonWebToken, JWTClaims, KeySet, errors
+from cachetools import TTLCache, cached
+from fastapi import Depends, HTTPException, Request, security
+
+from . import config, services
+
+logger = logging.getLogger(__name__)
+
+token_scheme = security.HTTPBearer()
+
+
+def get_settings(request: Request) -> config.Settings:
+    return request.app.extra["settings"]
+
+
+def get_jwks_url(settings: config.Settings = Depends(get_settings)) -> str:
+    return settings.jwks_url
+
+
+@cached(TTLCache(maxsize=1, ttl=3600))
+def get_jwks(jwks_url: str = Depends(get_jwks_url)) -> KeySet:
+    with requests.get(jwks_url) as response:
+        response.raise_for_status()
+        return JsonWebKey.import_key_set(response.json())
+
+
+def decode_token(
+    token: security.HTTPAuthorizationCredentials = Depends(token_scheme),
+    jwks: KeySet = Depends(get_jwks),
+) -> JWTClaims:
+    """
+    Validate & decode JWT
+    """
+    try:
+        claims = JsonWebToken(["RS256"]).decode(
+            s=token.credentials,
+            key=jwks,
+            claims_options={
+                # # Example of validating audience to match expected value
+                # "aud": {"essential": True, "values": [APP_CLIENT_ID]}
+            },
+        )
+
+        if "client_id" in claims:
+            # Insert Cognito's `client_id` into `aud` claim if `aud` claim is unset
+            claims.setdefault("aud", claims["client_id"])
+
+        claims.validate()
+        return claims
+    except errors.JoseError:  #
+        logger.exception("Unable to decode token")
+        raise HTTPException(status_code=403, detail="Bad auth token")
+
+
+def get_username_from_token(
+    claims: Optional[security.HTTPBasicCredentials] = Depends(decode_token),
+):
+    return claims["sub"]
+
+
+def get_username_from_request(provided_by: str):
+    return provided_by
+
+
+get_username = (
+    get_username_from_token if config.settings.jwks_url else get_username_from_request
+)
+
+
+def get_table(settings: config.Settings = Depends(get_settings)):
+    client = boto3.resource("dynamodb")
+    return client.Table(settings.dynamodb_table)
+
+
+def get_db(table=Depends(get_table)) -> services.Database:
+    return services.Database(table=table)
+
+
+def fetch_ingestion(
+    ingestion_id: str,
+    db: services.Database = Depends(get_db),
+    username: str = Depends(get_username),
+):
+    try:
+        return db.fetch_one(username=username, ingestion_id=ingestion_id)
+    except services.NotInDb:
+        raise HTTPException(
+            status_code=404, detail="No ingestion found with provided ID"
+        )

package/lib/ingestor-api/runtime/src/handler.py

@@ -0,0 +1,9 @@
+"""
+Entrypoint for Lambda execution.
+"""
+
+from mangum import Mangum
+
+from .main import app
+
+handler = Mangum(app, lifespan="off")

package/lib/ingestor-api/runtime/src/ingestor.py

@@ -0,0 +1,82 @@
+import os
+from datetime import datetime
+from typing import TYPE_CHECKING, Iterator, List, Optional, Sequence
+
+from boto3.dynamodb.types import TypeDeserializer
+
+from .config import settings
+from .dependencies import get_table
+from .schemas import Ingestion, Status
+from .utils import get_db_credentials, load_items
+
+if TYPE_CHECKING:
+    from aws_lambda_typing import context as context_
+    from aws_lambda_typing import events
+    from aws_lambda_typing.events.dynamodb_stream import DynamodbRecord
+
+
+def get_queued_ingestions(records: List["DynamodbRecord"]) -> Iterator[Ingestion]:
+    deserializer = TypeDeserializer()
+    for record in records:
+        # Parse Record
+        parsed = {
+            k: deserializer.deserialize(v)
+            for k, v in record["dynamodb"]["NewImage"].items()
+        }
+        ingestion = Ingestion.parse_obj(parsed)
+        if ingestion.status == Status.queued:
+            yield ingestion
+
+
+def update_dynamodb(
+    ingestions: Sequence[Ingestion],
+    status: Status,
+    message: Optional[str] = None,
+):
+    """
+    Bulk update DynamoDB with ingestion results.
+    """
+    # Update records in DynamoDB
+    print(f"Updating ingested items status in DynamoDB, marking as {status}...")
+    table = get_table(settings)
+    with table.batch_writer(overwrite_by_pkeys=["created_by", "id"]) as batch:
+        for ingestion in ingestions:
+            batch.put_item(
+                Item=ingestion.copy(
+                    update={
+                        "status": status,
+                        "message": message,
+                        "updated_at": datetime.now(),
+                    }
+                ).dynamodb_dict()
+            )
+
+
+def handler(event: "events.DynamoDBStreamEvent", context: "context_.Context"):
+    # Parse input
+    ingestions = list(get_queued_ingestions(event["Records"]))
+    if not ingestions:
+        print("No queued ingestions to process")
+        return
+
+    # Insert into PgSTAC DB
+    outcome = Status.succeeded
+    message = None
+    try:
+        load_items(
+            creds=get_db_credentials(os.environ["DB_SECRET_ARN"]),
+            ingestions=ingestions,
+        )
+    except Exception as e:
+        print(f"Encountered failure loading items into pgSTAC: {e}")
+        outcome = Status.failed
+        message = str(e)
+
+    # Update DynamoDB with outcome
+    update_dynamodb(
+        ingestions=ingestions,
+        status=outcome,
+        message=message,
+    )
+
+    print("Completed batch...")

package/lib/ingestor-api/runtime/src/loader.py

@@ -0,0 +1,21 @@
+"""Utilities to bulk load data into pgstac from json/ndjson."""
+import logging
+
+from pypgstac.load import Loader as BaseLoader
+
+logger = logging.getLogger(__name__)
+
+
+class Loader(BaseLoader):
+    """Utilities for loading data and updating collection summaries/extents."""
+
+    def __init__(self, db) -> None:
+        super().__init__(db)
+        self.check_version()
+        self.conn = self.db.connect()
+
+    def delete_collection(self, collection_id: str) -> None:
+        with self.conn.cursor() as cur:
+            with self.conn.transaction():
+                logger.info(f"Deleting collection: {collection_id}.")
+                cur.execute("SELECT pgstac.delete_collection(%s);", [collection_id])

package/lib/ingestor-api/runtime/src/main.py

@@ -0,0 +1,125 @@
+from fastapi import Depends, FastAPI, HTTPException
+
+from . import collection as collection_loader
+from . import config, dependencies, schemas, services
+
+app = FastAPI(
+    root_path=config.settings.root_path,
+    settings=config.settings,
+)
+
+
+@app.get(
+    "/ingestions", response_model=schemas.ListIngestionResponse, tags=["Ingestion"]
+)
+async def list_ingestions(
+    list_request: schemas.ListIngestionRequest = Depends(),
+    db: services.Database = Depends(dependencies.get_db),
+):
+    return db.fetch_many(
+        status=list_request.status, next=list_request.next, limit=list_request.limit
+    )
+
+
+@app.post(
+    "/ingestions",
+    response_model=schemas.Ingestion,
+    tags=["Ingestion"],
+    status_code=201,
+)
+async def create_ingestion(
+    item: schemas.AccessibleItem,
+    username: str = Depends(dependencies.get_username),
+    db: services.Database = Depends(dependencies.get_db),
+) -> schemas.Ingestion:
+    return schemas.Ingestion(
+        id=item.id,
+        created_by=username,
+        item=item,
+        status=schemas.Status.queued,
+    ).enqueue(db)
+
+
+@app.get(
+    "/ingestions/{ingestion_id}",
+    response_model=schemas.Ingestion,
+    tags=["Ingestion"],
+)
+def get_ingestion(
+    ingestion: schemas.Ingestion = Depends(dependencies.fetch_ingestion),
+) -> schemas.Ingestion:
+    return ingestion
+
+
+@app.patch(
+    "/ingestions/{ingestion_id}",
+    response_model=schemas.Ingestion,
+    tags=["Ingestion"],
+)
+def update_ingestion(
+    update: schemas.UpdateIngestionRequest,
+    ingestion: schemas.Ingestion = Depends(dependencies.fetch_ingestion),
+    db: services.Database = Depends(dependencies.get_db),
+):
+    updated_item = ingestion.copy(update=update.dict(exclude_unset=True))
+    return updated_item.save(db)
+
+
+@app.delete(
+    "/ingestions/{ingestion_id}",
+    response_model=schemas.Ingestion,
+    tags=["Ingestion"],
+)
+def cancel_ingestion(
+    ingestion: schemas.Ingestion = Depends(dependencies.fetch_ingestion),
+    db: services.Database = Depends(dependencies.get_db),
+) -> schemas.Ingestion:
+    if ingestion.status != schemas.Status.queued:
+        raise HTTPException(
+            status_code=400,
+            detail=(
+                "Unable to delete ingestion if status is not "
+                f"{schemas.Status.queued}"
+            ),
+        )
+    return ingestion.cancel(db)
+
+
+@app.post(
+    "/collections",
+    tags=["Collection"],
+    status_code=201,
+    dependencies=[Depends(dependencies.get_username)],
+)
+def publish_collection(collection: schemas.StacCollection):
+    # pgstac create collection
+    try:
+        collection_loader.ingest(collection)
+        return {f"Successfully published: {collection.id}"}
+    except Exception as e:
+        raise HTTPException(
+            status_code=400,
+            detail=(f"Unable to publish collection: {e}"),
+        )
+
+
+@app.delete(
+    "/collections/{collection_id}",
+    tags=["Collection"],
+    dependencies=[Depends(dependencies.get_username)],
+)
+def delete_collection(collection_id: str):
+    try:
+        collection_loader.delete(collection_id=collection_id)
+        return {f"Successfully deleted: {collection_id}"}
+    except Exception as e:
+        print(e)
+        raise HTTPException(status_code=400, detail=(f"{e}"))
+
+
+@app.get("/auth/me")
+def who_am_i(username=Depends(dependencies.get_username)):
+    """
+    Return username for the provided request
+    """
+    return {"username": username}