eoapi-cdk 11.5.0 → 11.6.0

package/lib/titiler-pgstac-api/index.js

@@ -69,7 +69,7 @@ class TitilerPgstacApiLambdaRuntime extends constructs_1.Construct {
 }
 exports.TitilerPgstacApiLambdaRuntime = TitilerPgstacApiLambdaRuntime;
 _a = JSII_RTTI_SYMBOL_1;
-TitilerPgstacApiLambdaRuntime[_a] = { fqn: "eoapi-cdk.TitilerPgstacApiLambdaRuntime", version: "11.5.0" };
+TitilerPgstacApiLambdaRuntime[_a] = { fqn: "eoapi-cdk.TitilerPgstacApiLambdaRuntime", version: "11.6.0" };
 class TitilerPgstacApiLambda extends constructs_1.Construct {
     constructor(scope, id, props) {
         super(scope, id);
@@ -109,5 +109,5 @@ class TitilerPgstacApiLambda extends constructs_1.Construct {
 }
 exports.TitilerPgstacApiLambda = TitilerPgstacApiLambda;
 _b = JSII_RTTI_SYMBOL_1;
-TitilerPgstacApiLambda[_b] = { fqn: "eoapi-cdk.TitilerPgstacApiLambda", version: "11.5.0" };
+TitilerPgstacApiLambda[_b] = { fqn: "eoapi-cdk.TitilerPgstacApiLambda", version: "11.6.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_apigatewayv2 as apigatewayv2,\n  aws_logs,\n  CfnOutput,\n  Duration,\n  aws_ec2 as ec2,\n  aws_iam as iam,\n  aws_lambda as lambda,\n  aws_rds as rds,\n  aws_secretsmanager as secretsmanager,\n  Stack,\n} from \"aws-cdk-lib\";\nimport { Construct } from \"constructs\";\nimport * as path from \"path\";\nimport { LambdaApiGateway } from \"../lambda-api-gateway\";\nimport {\n  CustomLambdaFunctionProps,\n  resolveLambdaCode,\n  extractDatabaseDependencies,\n  createLambdaVersionWithDependencies,\n} from \"../utils\";\n\n// default settings that can be overridden by the user-provided environment.\nlet defaultTitilerPgstacEnv: Record<string, string> = {\n  CPL_VSIL_CURL_ALLOWED_EXTENSIONS: \".tif,.TIF,.tiff\",\n  GDAL_CACHEMAX: \"200\",\n  GDAL_DISABLE_READDIR_ON_OPEN: \"EMPTY_DIR\",\n  GDAL_INGESTED_BYTES_AT_OPEN: \"32768\",\n  GDAL_HTTP_MERGE_CONSECUTIVE_RANGES: \"YES\",\n  GDAL_HTTP_MULTIPLEX: \"YES\",\n  GDAL_HTTP_VERSION: \"2\",\n  PYTHONWARNINGS: \"ignore\",\n  VSI_CACHE: \"TRUE\",\n  VSI_CACHE_SIZE: \"5000000\",\n  DB_MIN_CONN_SIZE: \"1\",\n  DB_MAX_CONN_SIZE: \"1\",\n};\n\nexport class TitilerPgstacApiLambdaRuntime extends Construct {\n  public readonly lambdaFunction: lambda.Function;\n\n  constructor(\n    scope: Construct,\n    id: string,\n    props: TitilerPgstacApiLambdaRuntimeProps,\n  ) {\n    super(scope, id);\n\n    const { code: userCode, ...otherLambdaOptions } =\n      props.lambdaFunctionOptions || {};\n\n    this.lambdaFunction = new lambda.Function(this, \"lambda\", {\n      // defaults\n      runtime: lambda.Runtime.PYTHON_3_12,\n      handler: \"titiler_pgstac_api.handler.handler\",\n      memorySize: 3008,\n      logRetention: aws_logs.RetentionDays.ONE_WEEK,\n      timeout: Duration.seconds(30),\n      code: resolveLambdaCode(userCode, path.join(__dirname, \"..\"), {\n        file: \"titiler-pgstac-api/runtime/Dockerfile\",\n        buildArgs: { PYTHON_VERSION: \"3.12\" },\n      }),\n      vpc: props.vpc,\n      vpcSubnets: props.subnetSelection,\n      allowPublicSubnet: true,\n      environment: {\n        ...defaultTitilerPgstacEnv,\n        ...props.apiEnv, // if user provided environment variables, merge them with the defaults.\n        PGSTAC_SECRET_ARN: props.dbSecret.secretArn,\n      },\n      snapStart: props.enableSnapStart\n        ? lambda.SnapStartConf.ON_PUBLISHED_VERSIONS\n        : undefined,\n      // overwrites defaults with user-provided configurable properties (excluding code)\n      ...otherLambdaOptions,\n    });\n\n    // grant access to buckets using addToRolePolicy\n    if (props.buckets) {\n      props.buckets.forEach((bucket) => {\n        this.lambdaFunction.addToRolePolicy(\n          new iam.PolicyStatement({\n            actions: [\"s3:GetObject\"],\n            resources: [`arn:aws:s3:::${bucket}/*`],\n          }),\n        );\n      });\n    }\n\n    props.dbSecret.grantRead(this.lambdaFunction);\n\n    if (props.vpc) {\n      this.lambdaFunction.connections.allowTo(\n        props.db,\n        ec2.Port.tcp(5432),\n        \"allow connections from titiler\",\n      );\n    }\n  }\n}\n\nexport interface TitilerPgstacApiLambdaRuntimeProps {\n  /**\n   * VPC into which the lambda should be deployed.\n   */\n  readonly vpc?: ec2.IVpc;\n\n  /**\n   * RDS Instance with installed pgSTAC or pgbouncer server.\n   */\n  readonly db: rds.IDatabaseInstance | ec2.IInstance;\n\n  /**\n   * Subnet into which the lambda should be deployed.\n   */\n  readonly subnetSelection?: ec2.SubnetSelection;\n\n  /**\n   * Secret containing connection information for pgSTAC database.\n   */\n  readonly dbSecret: secretsmanager.ISecret;\n\n  /**\n   * Customized environment variables to send to titiler-pgstac runtime. These will be merged with `defaultTitilerPgstacEnv`.\n   * The database secret arn is automatically added to the environment variables at deployment.\n   */\n  readonly apiEnv?: Record<string, string>;\n\n  /**\n   * list of buckets the lambda will be granted access to.\n   */\n  readonly buckets?: string[];\n\n  /**\n   * Enable SnapStart to reduce cold start latency.\n   *\n   * SnapStart creates a snapshot of the initialized Lambda function, allowing new instances\n   * to start from this pre-initialized state instead of starting from scratch.\n   *\n   * Benefits:\n   * - Significantly reduces cold start times (typically 10x faster)\n   * - Improves API response time for infrequent requests\n   *\n   * Considerations:\n   * - Additional cost: charges for snapshot storage and restore operations\n   * - Requires Lambda versioning (automatically configured by this construct)\n   * - Database connections are recreated on restore using snapshot lifecycle hooks\n   *\n   * @see https://docs.aws.amazon.com/lambda/latest/dg/snapstart.html\n   * @default false\n   */\n  readonly enableSnapStart?: boolean;\n\n  /**\n   * Can be used to override the default lambda function properties.\n   *\n   * @default - defined in the construct.\n   */\n  readonly lambdaFunctionOptions?: CustomLambdaFunctionProps;\n}\n\nexport class TitilerPgstacApiLambda extends Construct {\n  /**\n   * URL for the Titiler Pgstac API.\n   */\n  readonly url: string;\n\n  /**\n   * Lambda function for the Titiler Pgstac API.\n   */\n  readonly lambdaFunction: lambda.Function;\n\n  /**\n   * @deprecated - use lambdaFunction instead\n   */\n  public titilerPgstacLambdaFunction: lambda.Function;\n\n  constructor(\n    scope: Construct,\n    id: string,\n    props: TitilerPgstacApiLambdaProps,\n  ) {\n    super(scope, id);\n\n    const runtime = new TitilerPgstacApiLambdaRuntime(this, \"runtime\", {\n      vpc: props.vpc,\n      subnetSelection: props.subnetSelection,\n      db: props.db,\n      dbSecret: props.dbSecret,\n      apiEnv: props.apiEnv,\n      buckets: props.buckets,\n      enableSnapStart: props.enableSnapStart,\n      lambdaFunctionOptions: props.lambdaFunctionOptions,\n    });\n    this.titilerPgstacLambdaFunction = this.lambdaFunction =\n      runtime.lambdaFunction;\n\n    // Determine which lambda to use for API Gateway\n    let apiLambda: lambda.Function | lambda.Version;\n    if (props.enableSnapStart) {\n      // Extract dependencies from database if it's a PgStacDatabase with PgBouncer\n      const dbDependencies = extractDatabaseDependencies(props.db);\n\n      // Create version with dependencies to ensure snapshot creation waits\n      apiLambda = createLambdaVersionWithDependencies(\n        runtime.lambdaFunction,\n        dbDependencies,\n      );\n    } else {\n      apiLambda = runtime.lambdaFunction;\n    }\n\n    const { api } = new LambdaApiGateway(this, \"titlier-pgstac-api\", {\n      lambdaFunction: apiLambda,\n      domainName: props.domainName ?? props.titilerPgstacApiDomainName,\n    });\n\n    this.url = api.url!;\n\n    new CfnOutput(this, \"titiler-pgstac-api-output\", {\n      exportName: `${Stack.of(this).stackName}-titiler-pgstac-url`,\n      value: this.url,\n    });\n  }\n}\n\nexport interface TitilerPgstacApiLambdaProps\n  extends TitilerPgstacApiLambdaRuntimeProps {\n  /**\n   * Domain Name for the Titiler Pgstac API. If defined, will create the domain name and integrate it with the Titiler Pgstac API.\n   *\n   * @default - undefined.\n   */\n  readonly domainName?: apigatewayv2.IDomainName;\n\n  /**\n   * Custom Domain Name Options for Titiler Pgstac API,\n   *\n   * @deprecated Use 'domainName' instead.\n   * @default - undefined.\n   */\n  readonly titilerPgstacApiDomainName?: apigatewayv2.IDomainName;\n}\n"]}

package/lib/titiler-pgstac-api/runtime/pyproject.toml

@@ -4,8 +4,8 @@ version = "0.0.0"
 description = "titiler-pgstac-api runtime"
 requires-python = ">=3.12"
 dependencies = [
-    "mangum==0.19",
-    "titiler-pgstac[psycopg-binary]>=2.0.0,<2.1.0",
+    "mangum>=0.21.0",
+    "titiler-pgstac[psycopg-binary]>=2.1.0,<3.0.0",
 ]
 
 [dependency-groups]

package/lib/titiler-pgstac-api/runtime/src/titiler_pgstac_api/handler.py

@@ -1,18 +1,22 @@
-"""
-Handler for AWS Lambda.
-"""
+"""Handler for AWS Lambda."""
 
-import asyncio
+import logging
 import os
+from collections.abc import AsyncIterator, Mapping
+from contextlib import asynccontextmanager
+from typing import Any
 
 from mangum import Mangum
 from snapshot_restore_py import register_after_restore, register_before_snapshot
-from titiler.pgstac.db import connect_to_db
+from titiler.pgstac.db import close_db_connection, connect_to_db
 from titiler.pgstac.main import app
 from titiler.pgstac.settings import PostgresSettings
-from utils import get_secret_dict
+from utils import ensure_event_loop, get_secret_dict, run_async
+
+logger = logging.getLogger(__name__)
 
 _connection_initialized = False
+_original_lifespan = app.router.lifespan_context
 
 
 def _build_postgres_settings() -> PostgresSettings:
@@ -27,69 +31,94 @@ def _build_postgres_settings() -> PostgresSettings:
     )
 
 
-@register_before_snapshot
-def on_snapshot():
-    """
-    Runtime hook called by Lambda before taking a snapshot.
-    We close database connections that shouldn't be in the snapshot.
-    """
-
-    # Close any existing database connections before the snapshot is taken
+def _close_db_pool() -> None:
+    """Close the current database pool if one exists."""
     if hasattr(app, "state") and hasattr(app.state, "dbpool") and app.state.dbpool:
         try:
             app.state.dbpool.close()
+        except Exception:
+            logger.exception("SnapStart: error closing database pool")
+        finally:
             app.state.dbpool = None
-        except Exception as e:
-            print(f"SnapStart: Error closing database pool: {e}")
 
-    return {"statusCode": 200}
 
+async def _initialize_connection() -> None:
+    """Create a fresh database connection pool for the application."""
+    global _connection_initialized
 
-@register_after_restore
-def on_snap_restore():
-    """
-    Runtime hook called by Lambda after restoring from a snapshot.
-    We recreate database connections that were closed before the snapshot.
-    """
+    _close_db_pool()
+    await connect_to_db(app, settings=_build_postgres_settings())
+    _connection_initialized = True
+
+
+async def _shutdown_connection() -> None:
+    """Close the current database connection pool if it exists."""
     global _connection_initialized
 
-    try:
-        # Get the event loop or create a new one
-        try:
-            loop = asyncio.get_running_loop()
-        except RuntimeError:
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-
-        # Close any existing pool (from snapshot)
-        if hasattr(app.state, "dbpool") and app.state.dbpool:
-            try:
-                app.state.dbpool.close()
-            except Exception as e:
-                print(f"SnapStart: Error closing stale pool: {e}")
-            app.state.dbpool = None
+    if hasattr(app, "state") and hasattr(app.state, "dbpool") and app.state.dbpool:
+        await close_db_connection(app)
+        app.state.dbpool = None
+
+    _connection_initialized = False
 
-        # Create fresh connection pool
-        loop.run_until_complete(connect_to_db(app, settings=_build_postgres_settings()))
 
-        _connection_initialized = True
+@register_before_snapshot
+def on_snapshot() -> dict[str, int]:
+    """Close database connections before Lambda SnapStart takes a snapshot."""
+    _close_db_pool()
+    return {"statusCode": 200}
+
 
-    except Exception as e:
-        print(f"SnapStart: Failed to initialize database connection: {e}")
+@register_after_restore
+def on_snap_restore() -> dict[str, int]:
+    """Recreate database connections after Lambda SnapStart restores a snapshot."""
+    try:
+        run_async(_initialize_connection())
+    except Exception:
+        logger.exception("SnapStart: failed to initialize database connection")
         raise
 
     return {"statusCode": 200}
 
 
-@app.on_event("startup")
-async def startup_event() -> None:
-    """Connect to database on startup."""
-    await connect_to_db(app, settings=_build_postgres_settings())
+@asynccontextmanager
+async def lifespan(app_instance) -> AsyncIterator[Mapping[str, Any] | None]:
+    """Wrap the upstream lifespan with database setup and teardown.
 
+    We keep the app's lifespan wiring intact for non-Lambda contexts, but the
+    Lambda runtime below uses ``Mangum(..., lifespan="off")`` and performs
+    connection setup explicitly. In sandbox testing, Mangum lifespan handling
+    was not a drop-in replacement for Lambda-container-scoped pool reuse.
+    """
+    async with _original_lifespan(app_instance) as state:
+        await _initialize_connection()
+        try:
+            yield state
+        finally:
+            await _shutdown_connection()
+
+
+app.router.lifespan_context = lifespan
 
-handler = Mangum(app, lifespan="off")
+# The Lambda runtime initializes long-lived async resources on an installed
+# reusable loop, then hands request execution to Mangum. ``ensure_event_loop``
+# is a defensive step for those synchronous initialization paths. It is not here
+# because normal FastAPI route execution cannot run without it.
+_asgi_handler = Mangum(app, lifespan="off")
+
+
+def handler(event: Any, context: Any) -> dict[str, Any]:
+    """Handle AWS Lambda events with a reusable installed event loop.
+
+    This supports synchronous Lambda-side async setup such as cold-start and
+    SnapStart restore initialization before control passes to Mangum.
+    """
+    ensure_event_loop()
+    return _asgi_handler(event, context)
 
 
 if "AWS_EXECUTION_ENV" in os.environ:
-    loop = asyncio.get_event_loop()
-    loop.run_until_complete(app.router.startup())
+    # Avoid ``asyncio.run(...)`` here. It would create the pool on a temporary
+    # loop and then close it, which is a poor fit for container-scoped async
+    # resources that should live on the installed reusable loop.
+    run_async(_initialize_connection())