work out some changes to stac-api and titiler-pgstac handlers

Author: hrodmn

lib/stac-api/runtime/src/app.py

@@ -2,40 +2,57 @@
 FastAPI application using PGStac.
 """
 
+from brotli_asgi import BrotliMiddleware
+from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import ORJSONResponse
 from stac_fastapi.api.app import StacApi
+from stac_fastapi.api.middleware import ProxyHeaderMiddleware
+from stac_fastapi.pgstac.app import (
+    application_extensions,
+    collections_get_request_model,
+    get_request_model,
+    items_get_request_model,
+    post_request_model,
+)
 from stac_fastapi.pgstac.core import CoreCrudClient
 from stac_fastapi.pgstac.db import close_db_connection, connect_to_db
-from starlette_cramjam.middleware import CompressionMiddleware
+from starlette.middleware import Middleware
 
 from .config import ApiSettings
-from .config import extensions as PgStacExtensions
-from .config import get_request_model as GETModel
-from .config import post_request_model as POSTModel
 
-api_settings = ApiSettings()
+settings = ApiSettings()
 
 api = StacApi(
-    title=api_settings.name,
-    api_version=api_settings.version,
-    description=api_settings.description or api_settings.name,
-    settings=api_settings.load_postgres_settings(),
-    extensions=PgStacExtensions,
-    client=CoreCrudClient(post_request_model=POSTModel),
-    search_get_request_model=GETModel,
-    search_post_request_model=POSTModel,
+    app=FastAPI(
+        openapi_url=settings.openapi_url,
+        docs_url=settings.docs_url,
+        redoc_url=None,
+        root_path=settings.root_path,
+        title=settings.stac_fastapi_title,
+        version=settings.stac_fastapi_version,
+        description=settings.stac_fastapi_description,
+    ),
+    settings=settings,
+    extensions=application_extensions,
+    client=CoreCrudClient(pgstac_search_model=post_request_model),
     response_class=ORJSONResponse,
-    middlewares=[CompressionMiddleware],
+    items_get_request_model=items_get_request_model,
+    search_get_request_model=get_request_model,
+    search_post_request_model=post_request_model,
+    collections_get_request_model=collections_get_request_model,
+    middlewares=[
+        Middleware(BrotliMiddleware),
+        Middleware(ProxyHeaderMiddleware),
+    ],
 )
-
 app = api.app
 
 # Set all CORS enabled origins
-if api_settings.cors_origins:
+if settings.cors_origins:
     app.add_middleware(
         CORSMiddleware,
-        allow_origins=api_settings.cors_origins,
+        allow_origins=settings.cors_origins,
         allow_credentials=True,
         allow_methods=["GET", "POST", "OPTIONS"],
         allow_headers=["*"],

lib/stac-api/runtime/src/config.py

@@ -3,31 +3,21 @@
 
 import base64
 import json
-from typing import Optional
+from typing import Any, Optional
 
 import boto3
-import pydantic
-from stac_fastapi.api.models import create_get_request_model, create_post_request_model
 
 # from stac_fastapi.pgstac.extensions import QueryExtension
-from stac_fastapi.extensions.core import (
-    ContextExtension,
-    FieldsExtension,
-    FilterExtension,
-    QueryExtension,
-    SortExtension,
-    TokenPaginationExtension,
-)
+from pydantic import model_validator
 from stac_fastapi.pgstac.config import Settings
-from stac_fastapi.pgstac.types.search import PgstacSearch
+from stac_fastapi.pgstac.version import __version__ as stac_fastapi_pgstac_version
 
 
 def get_secret_dict(secret_name: str):
     """Retrieve secrets from AWS Secrets Manager
 
     Args:
         secret_name (str): name of aws secrets manager secret containing database connection secrets
-        profile_name (str, optional): optional name of aws profile for use in debugger only
 
     Returns:
         secrets (dict): decrypted secrets in dict
@@ -45,53 +35,30 @@ def get_secret_dict(secret_name: str):
         return json.loads(base64.b64decode(get_secret_value_response["SecretBinary"]))
 
 
-class ApiSettings(pydantic.BaseSettings):
+class ApiSettings(Settings):
     """API settings"""
 
-    name: str = "asdi-stac-api"
-    version: str = "0.1"
+    name: str = "stac-fastapi-pgstac"
+    version: str = stac_fastapi_pgstac_version
     description: Optional[str] = None
-    cors_origins: str = "*"
     cachecontrol: str = "public, max-age=3600"
     debug: bool = False
 
     pgstac_secret_arn: Optional[str]
 
-    @pydantic.validator("cors_origins")
-    def parse_cors_origin(cls, v):
-        """Parse CORS origins."""
-        return [origin.strip() for origin in v.split(",")]
-
-    def load_postgres_settings(self) -> "Settings":
-        """Load postgres connection params from AWS secret"""
-
-        if self.pgstac_secret_arn:
-            secret = get_secret_dict(self.pgstac_secret_arn)
-
-            return Settings(
-                postgres_host_reader=secret["host"],
-                postgres_host_writer=secret["host"],
-                postgres_dbname=secret["dbname"],
-                postgres_user=secret["username"],
-                postgres_pass=secret["password"],
-                postgres_port=secret["port"],
+    @model_validator(mode="before")
+    def get_postgres_setting(cls, data: Any) -> Any:
+        if arn := data.get("pgstac_secret_arn"):
+            secret = get_secret_dict(arn)
+            data.update(
+                {
+                    "postgres_host_reader": secret["host"],
+                    "postgres_host_writer": secret["host"],
+                    "postgres_dbname": secret["dbname"],
+                    "postgres_user": secret["username"],
+                    "postgres_pass": secret["password"],
+                    "postgres_port": secret["port"],
+                }
             )
-        else:
-            return Settings()
-
-    class Config:
-        """model config"""
-
-        env_file = ".env"
-
 
-extensions = [
-    FilterExtension(),
-    QueryExtension(),
-    SortExtension(),
-    FieldsExtension(),
-    TokenPaginationExtension(),
-    ContextExtension(),
-]
-post_request_model = create_post_request_model(extensions, base_model=PgstacSearch)
-get_request_model = create_get_request_model(extensions)
+        return data

lib/stac-api/runtime/src/handler.py

@@ -7,6 +7,22 @@
 
 from mangum import Mangum
 
+from .config import get_secret_dict
+
+pgstac_secret_arn = os.environ["PGSTAC_SECRET_ARN"]
+
+secret = get_secret_dict(pgstac_secret_arn)
+os.environ.update(
+    {
+        "postgres_host_reader": secret["host"],
+        "postgres_host_writer": secret["host"],
+        "postgres_dbname": secret["dbname"],
+        "postgres_user": secret["username"],
+        "postgres_pass": secret["password"],
+        "postgres_port": str(secret["port"]),
+    }
+)
+
 from .app import app
 
 handler = Mangum(app, lifespan="off")

lib/titiler-pgstac-api/runtime/Dockerfile

@@ -20,6 +20,12 @@ RUN find /asset -type f -name '*.py' -print0 | xargs -0 rm -f
 RUN find /asset -type d -name 'tests' -print0 | xargs -0 rm -rf
 RUN rm -rdf /asset/numpy/doc/ /asset/boto3* /asset/botocore* /asset/bin /asset/geos_license /asset/Misc
 
+# Strip debug symbols from compiled C/C++ code (except for numpy.libs!)
+RUN cd /asset && \
+  find . -type f -name '*.so*' \
+  -not -path "./numpy.libs/*" \
+  -exec strip --strip-unneeded {} \;
+
 COPY runtime/src/*.py /asset/
 
 CMD ["echo", "hello world"]

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

@@ -5,8 +5,7 @@
 import asyncio
 import os
 
-from mangum import Mangum
-from utils import get_secret_dict
+from .utils import get_secret_dict
 
 pgstac_secret_arn = os.environ["PGSTAC_SECRET_ARN"]
 
@@ -21,14 +20,31 @@
     }
 )
 
+from mangum import Mangum
 from titiler.pgstac.db import connect_to_db  # noqa: E402
 from titiler.pgstac.main import app  # noqa: E402
+from titiler.pgstac.settings import PostgresSettings
+from utils import get_secret_dict
 
 
 @app.on_event("startup")
 async def startup_event() -> None:
     """Connect to database on startup."""
-    await connect_to_db(app)
+    pgstac_secret_arn = os.getenv("PGSTAC_SECRET_ARN")
+    if not pgstac_secret_arn:
+        raise ValueError("PGSTAC_SECRET_ARN is not set!")
+
+    secret = get_secret_dict(pgstac_secret_arn)
+    await connect_to_db(
+        app,
+        settings=PostgresSettings(
+            postgres_user=secret["username"],
+            postgres_pass=secret["password"],
+            postgres_host=secret["host"],
+            postgres_port=secret["port"],
+            postgres_dbname=secret["dbname"],
+        ),
+    )
 
 
 handler = Mangum(app, lifespan="off")