private createFindLoadBalancerFunction()

in lib/ide-services-cloudfront.ts [92:153]
52 lines of code
4 McCabe index (conditional complexity)

    private createFindLoadBalancerFunction(): lambda.Function {
        // Create a Lambda function to find the ALB by its DNS name
        const fn = new lambda.Function(this, 'FindLoadBalancerFunction', {
            runtime: lambda.Runtime.NODEJS_22_X,
            handler: 'index.handler',
            code: lambda.Code.fromInline(`
                // Import AWS SDK v3 modules
                const { ElasticLoadBalancingV2Client, DescribeLoadBalancersCommand } = require('@aws-sdk/client-elastic-load-balancing-v2');
                const { EC2Client, DescribeSecurityGroupsCommand } = require('@aws-sdk/client-ec2');
    
                exports.handler = async (event) => {
                    console.log('Event:', JSON.stringify(event));
    
                    const namePrefix = event.ResourceProperties.namePrefix;
                    if (!namePrefix) {
                        throw new Error('ALB name prefix is required');
                    }
    
                    // Initialize AWS clients
                    const elbv2Client = new ElasticLoadBalancingV2Client();
                    const ec2Client = new EC2Client();
    
                    try {
                        // Get all load balancers
                        const describeLoadBalancersCommand = new DescribeLoadBalancersCommand({});
                        const loadBalancersResponse = await elbv2Client.send(describeLoadBalancersCommand);
                        console.log('Load balancers:', JSON.stringify(loadBalancersResponse));
    
                        // Find the load balancer with the matching DNS name
                        const loadBalancer = loadBalancersResponse.LoadBalancers.find(lb => lb.LoadBalancerName.startsWith(namePrefix));
                        if (!loadBalancer) {
                            throw new Error(\`Load balancer with name \${namePrefix} not found\`);
                        }
    
                        return {
                            PhysicalResourceId: loadBalancer.LoadBalancerArn,
                            Data: {
                                loadBalancerArn: loadBalancer.LoadBalancerArn,
                                securityGroupId: loadBalancer.SecurityGroups[0],
                                dnsName: loadBalancer.DNSName,
                            }
                        };
                    } catch (error) {
                        console.error('Error:', error);
                        throw error;
                    }
                };
            `),
            timeout: cdk.Duration.minutes(5),
        });

        // Grant the Lambda function permission to describe load balancers and security groups
        fn.addToRolePolicy(new iam.PolicyStatement({
            actions: [
                'elasticloadbalancing:DescribeLoadBalancers',
                'ec2:DescribeSecurityGroups'
            ],
            resources: ['*'],
        }));

        return fn;
    }