Application Using the AWS-ALB-FARGATE Solutions Construct Never Completes Deploying.

[codeandA]

Hello,

I'm using the AWS Solutions Constructs to deploy a mock Flask application onto AWS Fargate with an Application Load Balancer, but I'm encountering an issue where the service never completes deploying. Looking into the service and related asset security groups, everything looks correct as far as the ports and permissions. From the service perspective, it looks as though it's going from deploying to draining, leading to continuous restarts. I've outlined the relevant parts of the example code below and would greatly appreciate any insights or suggestions you might have.

This is the very simple code I'm deploying as a test.

Flask Application (app.py):

import os
from flask import Flask, jsonify

app = Flask(__name__)

@app.route("/")
def hello_world():
    test_variable = os.getenv("TEST_VARIABLE", "Default Value")
    return f"Value of TEST_VARIABLE: {test_variable}"

@app.route("/health")
def health_check():
    return jsonify({"status": "healthy"})

if __name__ == "__main__":
    app.run(debug=True, host="0.0.0.0")

This is the Dockerfile I'm using:

FROM python:3.11-alpine
WORKDIR /app
COPY . /app

RUN pip install --trusted-host pypi.python.org Flask

EXPOSE 5000

ENV FLASK_APP=app.py
CMD ["flask", "run", "--host=0.0.0.0"]

I've ensured the Flask application listens on port 5000 and the Docker container also exposes this port. My health check endpoint at /health returns a 200 status with a JSON response.

More importantly this is the AWS CDK Solutions Construct code:

from aws_cdk import aws_elasticloadbalancingv2 as alb
from aws_solutions_constructs.aws_alb_fargate import AlbToFargate
from constructs import Construct
from aws_cdk import App, Stack


class MyPythonTestBackendService(Stack):
    def __init__(self, scope: Construct, id: str, **kwargs):
        super().__init__(scope, id, **kwargs)

        # Create an ALB to Fargate service
        alb_fargate_service = AlbToFargate(
            self,
            "MyAlbToFargateService",
            ecr_repository_arn=REPOSITORY_ARN,
            ecr_image_version="latest",
            public_api=True,
            # load_balancer_props={"internet_facing": True},
            listener_props=alb.BaseApplicationListenerProps(
                protocol=alb.ApplicationProtocol.HTTP
            ),
            target_group_props={
                "protocol": alb.ApplicationProtocol.HTTP,
                "port": 5000,
                # "target_type": alb.TargetType.IP,  # This already seems to be the default.
                "health_check": alb.HealthCheck(path="/health"),
            },
            cluster_props={"container_insights": True},
            container_definition_props={
                "environment": {
                    "TEST_VARIABLE": "Test",
                },
                "portMappings": [{"containerPort": 5000}],
                # "cpu": 1024,
                # "memoryReservationMiB": 2048,
            },
            # fargate_task_definition_props={
            #     "cpu": "2048",
            #     "memoryLimitMiB": "4096",  
            # },
            # fargate_service_props={"assignPublicIp": "true"},
        )

I played around with the commented-out options in case the issue with the deployment was either an impossibility to reach some important resource from the private subnet where the service is deployed or some limitation with memory. However,  I believe things should work without those configurations. 

I also changed the target group's health check so it's configured to the "/health" endpoint of the Flask app (I also tried the default "/" route without any specification). Despite this, the ECS service is still continuously restarted and has never moved from deploying to completion. 

I believe that as is, this construct should be deployed out of the box. Could there be any configuration I'm overlooking that's causing this issue? Any advice or debugging tips would be immensely helpful.

Thank you in advance!