Input<Input<Subnet>[]>

const envCheckRule = new aws.lb.ListenerRule(pre('envCheckListener'), {
    conditions: [{
		pathPattern: {
			values: ["/environment-check*"],
		},
    }],
    actions: [{
        type: "fixed-response",
        fixedResponse: {
            contentType: "text/plain",
            statusCode: "200",
            messageBody: pulumi.interpolate`Check OK - ENV ${getStack()}`,
        },
    }],
    listenerArn: coreInfraStackRef.getOutput('port80ListenerArn'),
    priority: 50,  // We'll have the onboarding listener be a higher priority.
});

const serviceListenerRule = new aws.lb.ListenerRule(pre('mainServiceListener'), {
    conditions: [{
		pathPattern: {
			values: ["/*"],
		},
    }],
    actions: [{
        type: "forward",
        targetGroupArn: mainTargetGroup.arn,
    }],
    listenerArn: coreInfraStackRef.getOutput('port80ListenerArn'),
    priority: 500,  // We'll have the onboarding listener be a higher priority.
});

const pmbMainFargateService = new awsx.ecs.FargateService(pre('fargate-main'), {
    cluster: pmbServiceCluster.arn,
    name: pre('fargate-main'),
    assignPublicIp: true,
    healthCheckGracePeriodSeconds: 420,
    desiredCount: 1,
    taskDefinitionArgs: {
        logGroup: {
            existing: {
                name: pmbServiceMainLogGroup.name
            }
        },
        containers: {
            pmbWebApp: {
                name: "pmbWebApp",
                image: pmbMainDockerImage.repoDigest,
                cpu: 1024, //1024 = 1 VCPU
                memory: 2048, // MiB
                essential: true,
                healthCheck: {
                    interval: 25,
                    retries: 10,
                    command: ["CMD-SHELL", `ps x | grep puma | grep 0.0.0.0:${pmbMainAppPort}`]
                },
                portMappings: [{ 
                    targetGroup: mainTargetGroup,
                    containerPort: pmbMainAppPort,
                    hostPort: pmbMainAppPort,
                }],

const mainTargetGroup = new aws.lb.TargetGroup(pre('tg-main'), {
	port: pmbMainAppPort,
    protocol: "HTTP",
    targetType: "ip",
    vpcId: vpc.id,
	healthCheck: {
		interval: 30,
		timeout: 25,
		matcher: "200,304",
		path: "/favicon.ico",
		unhealthyThreshold: 10
	},
});

const listenerRule = new aws.lb.ListenerRule(pre('listener-s3'), {
    listenerArn: coreInfraStackRef.getOutput('port80ListenerArn'),  // Replace with your ALB listener ARN
    priority: 75,
    actions: [{
        type: "redirect",
        redirect: {
            protocol: "HTTP",  // or HTTPS if your bucket is set up with a custom domain and SSL
            port: "80",  // or 443 for HTTPS
            host: bucket.websiteEndpoint,
            path: "/#{path}",
            query: "#{query}",
            statusCode: "HTTP_301",
        },
    }],
    conditions: [{
		pathPattern: {
			values: ["/onboarding*"],
		},
    }]
});

404 Not Found
Code: NoSuchKey
Message: The specified key doe

main ALB seems to be requesting /onboarding when it should be requesting /

/onboarding/

The IDs of the security groups associated with the task or service. If you don't specify a security group, the default security group for the VPC is used.

vpc.getSubnetsIds('public')

vpc.getSubnetsIds('public');

pulumi:pulumi:Stack (domain-user-development):
    panic: runtime error: invalid memory address or nil pointer dereference
    [signal SIGSEGV: segmentation violation code=0x1 addr=0x0 pc=0xe05f6e]

aws:lambda:Function (domain-user-s3-lambda):
    error: aws:lambda/function:Function resource 'domain-user-s3-lambda' has a problem: Value for unconfigurable attribute. Can't configure a value for "vpc_config.0.vpc_id": its value will be decided automatically based on the result of applying this configuration.. Examine values at 'domain-user-s3-lambda.vpcConfig.vpcId'.

const lambdaSecurityGroup = new aws.ec2.SecurityGroup(pre('lambda-sg'), {
	vpcId: vpc.vpcId,
    description: "Security group for domain-user proxy lambda",
    egress: [
        {
            protocol: "-1",  // Allow all outbound traffic
            fromPort: 0,
            toPort: 0,
            cidrBlocks: ["0.0.0.0/0"],
        }
    ],
});

const lambdaTargetGroup = new aws.lb.TargetGroup(pre('tg-lambda'), {
    protocol: "HTTP",
    targetType: "lambda",
	port: 80,
    vpcId: vpc.vpcId
});

const proxyLambda = new aws.lambda.Function(pre('s3-lambda'), {
    runtime: aws.lambda.Runtime.NodeJS18dX,
    handler: "index.handler",
	// vpcConfig: {
	// 	subnetIds: vpc.privateSubnetIds,
	// 	securityGroupIds: [lambdaSecurityGroup.id],
	// },
    code: new pulumi.asset.AssetArchive({
        "index.js": new pulumi.asset.StringAsset(`
            const AWS = require('aws-sdk');
            const s3 = new AWS.S3();

            exports.handler = async (event) => {
				console.log('Starting Execution');
                const path = event.path.substring(1); // Remove the leading '/'

                try {
                    const s3Response = await s3.getObject({
                        Bucket: "${bucket.bucket}",
                        Key: path,
                    }).promise();

                    return {
                        statusCode: 200,
                        body: s3Response.Body.toString(),
                        headers: { "Content-Type": "text/plain" }, // Adjust based on your content
                    };
                } catch (error) {
                    return {
                        statusCode: 500,
                        body: "Internal Server Error",
                    };
                }
            };
        `),
    }),
    role: s3ReadRole.arn,
}, {dependsOn: [lambdaSecurityGroup, lambdaTargetGroup]});

+ subnetIds     : [
  +     [0]: "subnet-00ff847521ecd9d36"
  +     [1]: "subnet-04b5574c704aadda3"
  +     [2]: "subnet-08bab0e8ac3185463"
  +     [3]: "subnet-0a00949490c736325"
    ]

const listenerRule = new aws.lb.ListenerRule(pre('listener-s3'), {
    listenerArn: coreInfraStackRef.getOutput('port80ListenerArn'),
    priority: 75,
    actions: [{
        type: "forward",
		targetGroupArn: lambdaTargetGroup.arn
    }],
    conditions: [{
		pathPattern: {
			values: ["/onboarding*"],
		},
    }]
});

const lambdaTargetGroup = new aws.lb.TargetGroup(pre('tg-lambda'), {
    protocol: "HTTP",
    targetType: "lambda",
	port: 80,
    vpcId: vpc.vpcId
});
const lambdaElbPermission = new aws.lambda.Permission(pre('elb-permission'), {
    action: "lambda:InvokeFunction",
    function: proxyLambda.name,
    principal: "<http://elasticloadbalancing.amazonaws.com|elasticloadbalancing.amazonaws.com>",
    // If you're using an Application Load Balancer, you might also need to specify the source ARN:
    sourceArn: lambdaTargetGroup.arn
});

const listenerRule = new aws.lb.ListenerRule(pre('listener-s3'), {
    listenerArn: coreInfraStackRef.getOutput('port80ListenerArn'),
    priority: 75,
    actions: [{
        type: "forward",
		targetGroupArn: lambdaTargetGroup.arn
    }],
    conditions: [{
		pathPattern: {
			values: ["/onboarding*"],
		},
    }]
});

const envCheckRule = new aws.lb.ListenerRule(pre('envCheckListener'), {
    conditions: [{
		pathPattern: {
			values: ["/domain-user-check*"],
		},
    }],
    actions: [{
        type: "fixed-response",
        fixedResponse: {
            contentType: "text/plain",
            statusCode: "200",
            messageBody: pulumi.interpolate`User Domain Check OK - ENV ${getStack()}`,
        },
    }],
    listenerArn: coreInfraStackRef.getOutput('port80ListenerArn'),
    priority: 49,  // We'll have the onboarding listener be a higher priority.
});

const transformedOutput = bucket.bucket.apply(val => val);
const templateOut = pulumi.interpolate`${transformedOutput}`;
let bucketOut = ''
templateOut.apply(s => { bucketOut = s; });

                        Bucket: '${bucketOut}',

To get the value of an Output<T> as an Output<string> consider either:
1: o.apply(v => `prefix${v}suffix`)
2: pulumi.interpolate `prefix${v}suffix`

See <https://www.pulumi.com/docs/concepts/inputs-outputs> for more details.
This function may throw in a future version of @pulumi/pulumi.',

bucket.bucket.apply

const proxyLambda = new aws.lambda.Function(pre('s3-lambda'), {
    runtime: aws.lambda.Runtime.NodeJS18dX,
    handler: "index.handler",
	vpcConfig: {
		subnetIds: vpc.privateSubnetIds,
		securityGroupIds: [lambdaSecurityGroup.id],
	},
    code: new pulumi.asset.AssetArchive({
        "index.js": new pulumi.asset.StringAsset(`
            const AWS = require('aws-sdk');
            const s3 = new AWS.S3();

            exports.handler = async (event) => { // 16
				console.log('Starting Execution');
                const path = event.path.substring(1);

                try {
                    const s3Response = await s3.getObject({
                        Bucket: '${string}',
                        Key: path,
                    }).promise();

                    return {
                        statusCode: 200,
						statusDescription: "200 OK",
                        body: s3Response.Body.toString(),
                        headers: { "Content-Type": "text/plain" },
                    };
                } catch (error) {
                    return {
                        statusCode: 500,
                        body: "Internal Server Error",
                    };
                }
            };
        `),
    }),
    role: lambdaExecutionRole.arn,
}, {dependsOn: [lambdaExecutionRole, lambdaSecurityGroup, lambdaTargetGroup]});

let proxyLambda!: aws.lambda.Function;

bucket.bucket.apply(s => {
	proxyLambda = new aws.lambda.Function(pre('s3-lambda'), {
		runtime: aws.lambda.Runtime.NodeJS18dX,
		handler: "index.handler",
		vpcConfig: {
			subnetIds: vpc.privateSubnetIds,
			securityGroupIds: [lambdaSecurityGroup.id],
		},
		code: new pulumi.asset.AssetArchive({
			"index.js": new pulumi.asset.StringAsset(`
				const AWS = require('aws-sdk');
				const s3 = new AWS.S3();
	
				exports.handler = async (event) => { // 16
					console.log('Starting Execution');
					const path = event.path.substring(1);
	
					try {
						const s3Response = await s3.getObject({
							Bucket: '${s}',
							Key: path,
						}).promise();
	
						return {
							statusCode: 200,
							statusDescription: "200 OK",
							body: s3Response.Body.toString(),
							headers: { "Content-Type": "text/plain" },
						};
					} catch (error) {
						return {
							statusCode: 500,
							body: "Internal Server Error",
						};
					}
				};
			`),
		}),
		role: lambdaExecutionRole.arn,
	}, {dependsOn: [lambdaExecutionRole, lambdaSecurityGroup, lambdaTargetGroup]});
})