add titiler-xarray lambda deployment and remove ecs (#1175)

* add titiler-xarray lambda deployment and remove ecs

* add xarray/zarr version in /healthz

Author: vincentsarago

deployment/aws/README.md

@@ -4,4 +4,3 @@ Intro: https://developmentseed.org/titiler/deployment/aws/intro/
 
 AWS lambda: https://developmentseed.org/titiler/deployment/aws/lambda/
 
-ECS/Fargate: https://developmentseed.org/titiler/deployment/aws/ecs/

deployment/aws/cdk/app.py

@@ -1,13 +1,10 @@
 """Construct App."""
 
 import os
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional
 
 from aws_cdk import App, CfnOutput, Duration, Stack, Tags
 from aws_cdk import aws_apigatewayv2 as apigw
-from aws_cdk import aws_ec2 as ec2
-from aws_cdk import aws_ecs as ecs
-from aws_cdk import aws_ecs_patterns as ecs_patterns
 from aws_cdk import aws_iam as iam
 from aws_cdk import aws_lambda
 from aws_cdk import aws_logs as logs
@@ -47,6 +44,7 @@ def __init__(
         permissions = permissions or []
         environment = environment or {}
 
+        # COG / STAC / MosaicJSON
         lambda_function = aws_lambda.Function(
             self,
             f"{id}-lambda",
@@ -79,91 +77,38 @@ def __init__(
         )
         CfnOutput(self, "Endpoint", value=api.url)
 
-
-class titilerECSStack(Stack):
-    """Titiler ECS Fargate Stack."""
-
-    def __init__(
-        self,
-        scope: Construct,
-        id: str,
-        cpu: Union[int, float] = 256,
-        memory: Union[int, float] = 512,
-        mincount: int = 1,
-        maxcount: int = 50,
-        permissions: Optional[List[iam.PolicyStatement]] = None,
-        environment: Optional[Dict] = None,
-        code_dir: str = "./",
-        **kwargs: Any,
-    ) -> None:
-        """Define stack."""
-        super().__init__(scope, id, *kwargs)
-
-        permissions = permissions or []
-        environment = environment or {}
-
-        vpc = ec2.Vpc(self, f"{id}-vpc", max_azs=2)
-
-        cluster = ecs.Cluster(self, f"{id}-cluster", vpc=vpc)
-
-        task_env = environment.copy()
-        task_env.update({"LOG_LEVEL": "error"})
-
-        # GUNICORN configuration
-        if settings.workers_per_core:
-            task_env.update({"WORKERS_PER_CORE": str(settings.workers_per_core)})
-        if settings.max_workers:
-            task_env.update({"MAX_WORKERS": str(settings.max_workers)})
-        if settings.web_concurrency:
-            task_env.update({"WEB_CONCURRENCY": str(settings.web_concurrency)})
-
-        fargate_service = ecs_patterns.ApplicationLoadBalancedFargateService(
+        # Xarray
+        xarray_lambda_function = aws_lambda.Function(
             self,
-            f"{id}-service",
-            cluster=cluster,
-            cpu=cpu,
-            memory_limit_mib=memory,
-            desired_count=mincount,
-            public_load_balancer=True,
-            listener_port=80,
-            task_image_options=ecs_patterns.ApplicationLoadBalancedTaskImageOptions(
-                image=ecs.ContainerImage.from_registry(
-                    f"ghcr.io/developmentseed/titiler:{settings.image_version}",
-                ),
-                container_port=80,
-                environment=task_env,
+            f"{id}-xarray-lambda",
+            runtime=runtime,
+            code=aws_lambda.Code.from_docker_build(
+                path=os.path.abspath(code_dir),
+                file="lambda/Dockerfile.xarray",
+                platform="linux/amd64",
+                build_args={
+                    "PYTHON_VERSION": "3.12",
+                },
             ),
+            handler="handler.handler",
+            memory_size=memory,
+            reserved_concurrent_executions=concurrent,
+            timeout=Duration.seconds(timeout),
+            environment=environment,
+            log_retention=logs.RetentionDays.ONE_WEEK,
         )
-        fargate_service.target_group.configure_health_check(path="/healthz")
 
         for perm in permissions:
-            fargate_service.task_definition.task_role.add_to_policy(perm)
-
-        scalable_target = fargate_service.service.auto_scale_task_count(
-            min_capacity=mincount, max_capacity=maxcount
-        )
+            xarray_lambda_function.add_to_role_policy(perm)
 
-        # https://github.com/awslabs/aws-rails-provisioner/blob/263782a4250ca1820082bfb059b163a0f2130d02/lib/aws-rails-provisioner/scaling.rb#L343-L387
-        scalable_target.scale_on_request_count(
-            "RequestScaling",
-            requests_per_target=50,
-            scale_in_cooldown=Duration.seconds(240),
-            scale_out_cooldown=Duration.seconds(30),
-            target_group=fargate_service.target_group,
-        )
-
-        # scalable_target.scale_on_cpu_utilization(
-        #     "CpuScaling", target_utilization_percent=70,
-        # )
-
-        fargate_service.service.connections.allow_from_any_ipv4(
-            port_range=ec2.Port(
-                protocol=ec2.Protocol.ALL,
-                string_representation="All port 80",
-                from_port=80,
+        xarray_api = apigw.HttpApi(
+            self,
+            f"{id}-xarray-endpoint",
+            default_integration=HttpLambdaIntegration(
+                f"{id}-xarray-integration", handler=xarray_lambda_function
             ),
-            description="Allows traffic on port 80 from ALB",
         )
+        CfnOutput(self, "Xarray-Endpoint", value=xarray_api.url)
 
 
 app = App()
@@ -179,18 +124,6 @@ def __init__(
         )
     )
 
-
-ecs_stack = titilerECSStack(
-    app,
-    f"{settings.name}-ecs-{settings.stage}",
-    cpu=settings.task_cpu,
-    memory=settings.task_memory,
-    mincount=settings.min_ecs_instances,
-    maxcount=settings.max_ecs_instances,
-    permissions=perms,
-    environment=settings.env,
-)
-
 lambda_stack = titilerLambdaStack(
     app,
     f"{settings.name}-lambda-{settings.stage}",
@@ -209,7 +142,6 @@ def __init__(
     "Client": settings.client,
 }.items():
     if value:
-        Tags.of(ecs_stack).add(key, value)
         Tags.of(lambda_stack).add(key, value)
 
 

deployment/aws/cdk/config.py

@@ -38,42 +38,6 @@ class StackSettings(BaseSettings):
     # S3 key pattern to limit the access to specific items (e.g: "my_data/*.tif")
     key: str = "*"
 
-    ###########################################################################
-    # AWS ECS
-    # The following settings only apply to AWS ECS deployment
-    min_ecs_instances: int = 5
-    max_ecs_instances: int = 50
-
-    # CPU value      |   Memory value
-    # 256 (.25 vCPU) | 0.5 GB, 1 GB, 2 GB
-    # 512 (.5 vCPU)  | 1 GB, 2 GB, 3 GB, 4 GB
-    # 1024 (1 vCPU)  | 2 GB, 3 GB, 4 GB, 5 GB, 6 GB, 7 GB, 8 GB
-    # 2048 (2 vCPU)  | Between 4 GB and 16 GB in 1-GB increments
-    # 4096 (4 vCPU)  | Between 8 GB and 30 GB in 1-GB increments
-    task_cpu: int = 256
-    task_memory: int = 512
-
-    # GUNICORN configuration
-    # Ref: https://github.com/developmentseed/titiler/issues/119
-
-    # WORKERS_PER_CORE
-    # This image will check how many CPU cores are available in the current server running your container.
-    # It will set the number of workers to the number of CPU cores multiplied by this value.
-    workers_per_core: int = 1
-
-    # MAX_WORKERS
-    # You can use it to let the image compute the number of workers automatically but making sure it's limited to a maximum.
-    # should depends on `task_cpu`
-    max_workers: int = 1
-
-    # WEB_CONCURRENCY
-    # Override the automatic definition of number of workers.
-    # Set to the number of CPU cores in the current server multiplied by the environment variable WORKERS_PER_CORE.
-    # So, in a server with 2 cores, by default it will be set to 2.
-    web_concurrency: Optional[int] = None
-
-    image_version: str = "latest"
-
     ###########################################################################
     # AWS LAMBDA
     # The following settings only apply to AWS Lambda deployment

deployment/aws/lambda/Dockerfile

@@ -22,6 +22,7 @@ COPY lambda/handler.py /asset/handler.py
 # Ref: https://github.com/developmentseed/titiler/discussions/1108#discussioncomment-13045681
 RUN cp /usr/lib64/libexpat.so.1 /asset/
 
-ENV LAMBDA_TASK_ROOT /asset
+WORKDIR /asset
+RUN python -c "from handler import handler; print('All Good')"
 
 CMD ["echo", "hello world"]

deployment/aws/lambda/Dockerfile.xarray

@@ -0,0 +1,28 @@
+ARG PYTHON_VERSION=3.12
+
+FROM --platform=linux/amd64 public.ecr.aws/lambda/python:${PYTHON_VERSION}
+
+WORKDIR /tmp
+
+# Install system dependencies to compile (numexpr)
+RUN dnf install -y gcc-c++ && dnf clean all
+
+RUN python -m pip install pip -U
+RUN python -m pip install "titiler.xarray==0.22.3" "mangum>=0.10.0" "aiobotocore==2.17.0" "zarr" "s3fs" "aiohttp" "h5netcdf" "starlette-cramjam" "cftime" -t /asset --no-binary pydantic,xarray,numpy,pandas
+
+# Reduce package size and remove useless files
+RUN cd /asset && find . -type f -name '*.pyc' | while read f; do n=$(echo $f | sed 's/__pycache__\///' | sed 's/.cpython-[0-9]*//'); cp $f $n; done;
+RUN cd /asset && find . -type d -a -name '__pycache__' -print0 | xargs -0 rm -rf
+RUN cd /asset && find . -type f -a -name '*.py' -print0 | xargs -0 rm -f
+RUN find /asset -type d -a -name 'tests' -print0 | xargs -0 rm -rf
+RUN rm -rdf /asset/numpy/doc/ /asset/boto3* /asset/botocore* /asset/bin /asset/geos_license /asset/Misc
+
+COPY lambda/xarray_handler.py /asset/handler.py
+
+# Ref: https://github.com/developmentseed/titiler/discussions/1108#discussioncomment-13045681
+RUN cp /usr/lib64/libexpat.so.1 /asset/
+
+WORKDIR /asset
+RUN python -c "from handler import handler; print('All Good')"
+
+CMD ["echo", "hello world"]