AWS Load Balancers: Complete Guide - Application, Network, Gateway, and Classic Load Balancers Comparison with Implementation

 1<dependencies>
 2    <!-- AWS SDK for ELB v2 -->
 3    <dependency>
 4        <groupId>software.amazon.awssdk</groupId>
 5        <artifactId>elasticloadbalancingv2</artifactId>
 6        <version>2.21.29</version>
 7    </dependency>
 8
 9    <!-- AWS SDK for EC2 (for target management) -->
10    <dependency>
11        <groupId>software.amazon.awssdk</groupId>
12        <artifactId>ec2</artifactId>
13        <version>2.21.29</version>
14    </dependency>
15
16    <!-- Spring Boot for application -->
17    <dependency>
18        <groupId>org.springframework.boot</groupId>
19        <artifactId>spring-boot-starter-web</artifactId>
20    </dependency>
21
22    <!-- Metrics and monitoring -->
23    <dependency>
24        <groupId>io.micrometer</groupId>
25        <artifactId>micrometer-registry-cloudwatch</artifactId>
26    </dependency>
27</dependencies>

  1@Service
  2@Slf4j
  3public class ApplicationLoadBalancerService {
  4
  5    private final ElasticLoadBalancingV2Client elbClient;
  6    private final Ec2Client ec2Client;
  7    private final String region;
  8    private final String accountId;
  9
 10    public ApplicationLoadBalancerService(@Value("${aws.region}") String region,
 11                                        @Value("${aws.account-id}") String accountId) {
 12        this.region = region;
 13        this.accountId = accountId;
 14        this.elbClient = ElasticLoadBalancingV2Client.builder()
 15            .region(Region.of(region))
 16            .build();
 17        this.ec2Client = Ec2Client.builder()
 18            .region(Region.of(region))
 19            .build();
 20    }
 21
 22    public String createApplicationLoadBalancer(ALBConfiguration config) {
 23        try {
 24            // 1. Create the load balancer
 25            CreateLoadBalancerRequest request = CreateLoadBalancerRequest.builder()
 26                .name(config.getName())
 27                .scheme(config.isInternetFacing() ? Scheme.INTERNET_FACING : Scheme.INTERNAL)
 28                .type(LoadBalancerTypeEnum.APPLICATION)
 29                .ipAddressType(config.getIpAddressType())
 30                .subnets(config.getSubnetIds())
 31                .securityGroups(config.getSecurityGroupIds())
 32                .tags(Tag.builder()
 33                    .key("Environment")
 34                    .value(config.getEnvironment())
 35                    .build(),
 36                    Tag.builder()
 37                    .key("Application")
 38                    .value(config.getApplicationName())
 39                    .build())
 40                .build();
 41
 42            CreateLoadBalancerResponse response = elbClient.createLoadBalancer(request);
 43            String loadBalancerArn = response.loadBalancers().get(0).loadBalancerArn();
 44
 45            log.info("Created Application Load Balancer: {} with ARN: {}", config.getName(), loadBalancerArn);
 46
 47            // 2. Create target group
 48            String targetGroupArn = createTargetGroup(config, loadBalancerArn);
 49
 50            // 3. Create listener
 51            createListener(loadBalancerArn, targetGroupArn, config);
 52
 53            // 4. Configure health checks
 54            configureHealthCheck(targetGroupArn, config.getHealthCheckConfig());
 55
 56            return loadBalancerArn;
 57
 58        } catch (Exception e) {
 59            log.error("Failed to create Application Load Balancer: {}", config.getName(), e);
 60            throw new RuntimeException("ALB creation failed", e);
 61        }
 62    }
 63
 64    private String createTargetGroup(ALBConfiguration config, String loadBalancerArn) {
 65        try {
 66            CreateTargetGroupRequest request = CreateTargetGroupRequest.builder()
 67                .name(config.getName() + "-tg")
 68                .protocol(ProtocolEnum.HTTP)
 69                .port(config.getTargetPort())
 70                .vpcId(config.getVpcId())
 71                .targetType(config.getTargetType())
 72                .healthCheckEnabled(true)
 73                .healthCheckPath(config.getHealthCheckConfig().getPath())
 74                .healthCheckProtocol(ProtocolEnum.HTTP)
 75                .healthCheckPort("traffic-port")
 76                .healthCheckIntervalSeconds(config.getHealthCheckConfig().getInterval())
 77                .healthyThresholdCount(config.getHealthCheckConfig().getHealthyThreshold())
 78                .unhealthyThresholdCount(config.getHealthCheckConfig().getUnhealthyThreshold())
 79                .healthCheckTimeoutSeconds(config.getHealthCheckConfig().getTimeout())
 80                .matcher(Matcher.builder()
 81                    .httpCode(config.getHealthCheckConfig().getSuccessCodes())
 82                    .build())
 83                .tags(Tag.builder()
 84                    .key("LoadBalancer")
 85                    .value(loadBalancerArn)
 86                    .build())
 87                .build();
 88
 89            CreateTargetGroupResponse response = elbClient.createTargetGroup(request);
 90            String targetGroupArn = response.targetGroups().get(0).targetGroupArn();
 91
 92            log.info("Created target group: {} with ARN: {}", config.getName() + "-tg", targetGroupArn);
 93            return targetGroupArn;
 94
 95        } catch (Exception e) {
 96            log.error("Failed to create target group for ALB: {}", config.getName(), e);
 97            throw new RuntimeException("Target group creation failed", e);
 98        }
 99    }
100
101    private void createListener(String loadBalancerArn, String targetGroupArn, ALBConfiguration config) {
102        try {
103            CreateListenerRequest.Builder requestBuilder = CreateListenerRequest.builder()
104                .loadBalancerArn(loadBalancerArn)
105                .protocol(ProtocolEnum.HTTP)
106                .port(80)
107                .defaultActions(Action.builder()
108                    .type(ActionTypeEnum.FORWARD)
109                    .targetGroupArn(targetGroupArn)
110                    .build());
111
112            // Add HTTPS listener if SSL certificate is provided
113            if (config.getSslCertificateArn() != null) {
114                // Create HTTPS listener
115                CreateListenerRequest httpsRequest = CreateListenerRequest.builder()
116                    .loadBalancerArn(loadBalancerArn)
117                    .protocol(ProtocolEnum.HTTPS)
118                    .port(443)
119                    .certificates(Certificate.builder()
120                        .certificateArn(config.getSslCertificateArn())
121                        .build())
122                    .sslPolicy(config.getSslPolicy())
123                    .defaultActions(Action.builder()
124                        .type(ActionTypeEnum.FORWARD)
125                        .targetGroupArn(targetGroupArn)
126                        .build())
127                    .build();
128
129                elbClient.createListener(httpsRequest);
130
131                // Redirect HTTP to HTTPS
132                requestBuilder.defaultActions(Action.builder()
133                    .type(ActionTypeEnum.REDIRECT)
134                    .redirectConfig(RedirectActionConfig.builder()
135                        .protocol("HTTPS")
136                        .port("443")
137                        .statusCode(HttpRedirectActionStatusCodeEnum.HTTP_301)
138                        .build())
139                    .build());
140            }
141
142            elbClient.createListener(requestBuilder.build());
143            log.info("Created listeners for ALB: {}", loadBalancerArn);
144
145        } catch (Exception e) {
146            log.error("Failed to create listeners for ALB: {}", loadBalancerArn, e);
147            throw new RuntimeException("Listener creation failed", e);
148        }
149    }
150
151    public void registerTargets(String targetGroupArn, List<String> targetIds) {
152        try {
153            List<TargetDescription> targets = targetIds.stream()
154                .map(id -> TargetDescription.builder()
155                    .id(id)
156                    .build())
157                .collect(Collectors.toList());
158
159            RegisterTargetsRequest request = RegisterTargetsRequest.builder()
160                .targetGroupArn(targetGroupArn)
161                .targets(targets)
162                .build();
163
164            elbClient.registerTargets(request);
165            log.info("Registered {} targets to target group: {}", targetIds.size(), targetGroupArn);
166
167        } catch (Exception e) {
168            log.error("Failed to register targets to target group: {}", targetGroupArn, e);
169            throw new RuntimeException("Target registration failed", e);
170        }
171    }
172
173    public void createAdvancedRoutingRules(String listenerArn, List<RoutingRule> rules) {
174        try {
175            List<Rule> listenerRules = new ArrayList<>();
176            int priority = 100;
177
178            for (RoutingRule rule : rules) {
179                Rule listenerRule = Rule.builder()
180                    .priority(String.valueOf(priority++))
181                    .conditions(createRuleConditions(rule))
182                    .actions(createRuleActions(rule))
183                    .build();
184
185                listenerRules.add(listenerRule);
186            }
187
188            CreateRuleRequest request = CreateRuleRequest.builder()
189                .listenerArn(listenerArn)
190                .priority(String.valueOf(priority))
191                .conditions(listenerRules.get(0).conditions())
192                .actions(listenerRules.get(0).actions())
193                .build();
194
195            for (Rule rule : listenerRules) {
196                CreateRuleRequest ruleRequest = CreateRuleRequest.builder()
197                    .listenerArn(listenerArn)
198                    .priority(rule.priority())
199                    .conditions(rule.conditions())
200                    .actions(rule.actions())
201                    .build();
202
203                elbClient.createRule(ruleRequest);
204            }
205
206            log.info("Created {} advanced routing rules for listener: {}", rules.size(), listenerArn);
207
208        } catch (Exception e) {
209            log.error("Failed to create routing rules for listener: {}", listenerArn, e);
210            throw new RuntimeException("Rule creation failed", e);
211        }
212    }
213
214    private List<RuleCondition> createRuleConditions(RoutingRule rule) {
215        List<RuleCondition> conditions = new ArrayList<>();
216
217        if (rule.getPathPattern() != null) {
218            conditions.add(RuleCondition.builder()
219                .field("path-pattern")
220                .values(rule.getPathPattern())
221                .build());
222        }
223
224        if (rule.getHostHeader() != null) {
225            conditions.add(RuleCondition.builder()
226                .field("host-header")
227                .values(rule.getHostHeader())
228                .build());
229        }
230
231        if (rule.getHttpHeader() != null) {
232            conditions.add(RuleCondition.builder()
233                .field("http-header")
234                .httpHeaderConfig(HttpHeaderConditionConfig.builder()
235                    .httpHeaderName(rule.getHttpHeader().getKey())
236                    .values(rule.getHttpHeader().getValue())
237                    .build())
238                .build());
239        }
240
241        if (rule.getQueryString() != null) {
242            conditions.add(RuleCondition.builder()
243                .field("query-string")
244                .queryStringConfig(QueryStringConditionConfig.builder()
245                    .values(QueryStringKeyValuePair.builder()
246                        .key(rule.getQueryString().getKey())
247                        .value(rule.getQueryString().getValue())
248                        .build())
249                    .build())
250                .build());
251        }
252
253        return conditions;
254    }
255
256    private List<Action> createRuleActions(RoutingRule rule) {
257        List<Action> actions = new ArrayList<>();
258
259        switch (rule.getActionType()) {
260            case FORWARD:
261                actions.add(Action.builder()
262                    .type(ActionTypeEnum.FORWARD)
263                    .targetGroupArn(rule.getTargetGroupArn())
264                    .build());
265                break;
266
267            case REDIRECT:
268                actions.add(Action.builder()
269                    .type(ActionTypeEnum.REDIRECT)
270                    .redirectConfig(RedirectActionConfig.builder()
271                        .protocol(rule.getRedirectConfig().getProtocol())
272                        .host(rule.getRedirectConfig().getHost())
273                        .port(rule.getRedirectConfig().getPort())
274                        .path(rule.getRedirectConfig().getPath())
275                        .statusCode(HttpRedirectActionStatusCodeEnum.fromValue(rule.getRedirectConfig().getStatusCode()))
276                        .build())
277                    .build());
278                break;
279
280            case FIXED_RESPONSE:
281                actions.add(Action.builder()
282                    .type(ActionTypeEnum.FIXED_RESPONSE)
283                    .fixedResponseConfig(FixedResponseActionConfig.builder()
284                        .statusCode(rule.getFixedResponse().getStatusCode())
285                        .contentType(rule.getFixedResponse().getContentType())
286                        .messageBody(rule.getFixedResponse().getMessageBody())
287                        .build())
288                    .build());
289                break;
290
291            case WEIGHTED_FORWARD:
292                actions.add(Action.builder()
293                    .type(ActionTypeEnum.FORWARD)
294                    .forwardConfig(ForwardActionConfig.builder()
295                        .targetGroups(rule.getWeightedTargets().stream()
296                            .map(wt -> TargetGroupTuple.builder()
297                                .targetGroupArn(wt.getTargetGroupArn())
298                                .weight(wt.getWeight())
299                                .build())
300                            .collect(Collectors.toList()))
301                        .build())
302                    .build());
303                break;
304        }
305
306        return actions;
307    }
308
309    private void configureHealthCheck(String targetGroupArn, HealthCheckConfig healthConfig) {
310        try {
311            ModifyTargetGroupRequest request = ModifyTargetGroupRequest.builder()
312                .targetGroupArn(targetGroupArn)
313                .healthCheckEnabled(true)
314                .healthCheckPath(healthConfig.getPath())
315                .healthCheckIntervalSeconds(healthConfig.getInterval())
316                .healthCheckTimeoutSeconds(healthConfig.getTimeout())
317                .healthyThresholdCount(healthConfig.getHealthyThreshold())
318                .unhealthyThresholdCount(healthConfig.getUnhealthyThreshold())
319                .matcher(Matcher.builder()
320                    .httpCode(healthConfig.getSuccessCodes())
321                    .build())
322                .build();
323
324            elbClient.modifyTargetGroup(request);
325            log.info("Configured health check for target group: {}", targetGroupArn);
326
327        } catch (Exception e) {
328            log.error("Failed to configure health check for target group: {}", targetGroupArn, e);
329            throw new RuntimeException("Health check configuration failed", e);
330        }
331    }
332
333    // Supporting configuration classes
334    public static class ALBConfiguration {
335        private String name;
336        private boolean internetFacing;
337        private IpAddressType ipAddressType = IpAddressType.IPV4;
338        private List<String> subnetIds;
339        private List<String> securityGroupIds;
340        private String vpcId;
341        private String environment;
342        private String applicationName;
343        private int targetPort = 80;
344        private TargetTypeEnum targetType = TargetTypeEnum.INSTANCE;
345        private String sslCertificateArn;
346        private String sslPolicy = "ELBSecurityPolicy-TLS-1-2-2017-01";
347        private HealthCheckConfig healthCheckConfig = new HealthCheckConfig();
348
349        // Constructors, getters, setters
350        public ALBConfiguration() {}
351
352        public ALBConfiguration(String name, List<String> subnetIds, List<String> securityGroupIds, String vpcId) {
353            this.name = name;
354            this.subnetIds = subnetIds;
355            this.securityGroupIds = securityGroupIds;
356            this.vpcId = vpcId;
357            this.internetFacing = true;
358            this.environment = "production";
359        }
360
361        // Getters and setters
362        public String getName() { return name; }
363        public void setName(String name) { this.name = name; }
364        public boolean isInternetFacing() { return internetFacing; }
365        public void setInternetFacing(boolean internetFacing) { this.internetFacing = internetFacing; }
366        public IpAddressType getIpAddressType() { return ipAddressType; }
367        public void setIpAddressType(IpAddressType ipAddressType) { this.ipAddressType = ipAddressType; }
368        public List<String> getSubnetIds() { return subnetIds; }
369        public void setSubnetIds(List<String> subnetIds) { this.subnetIds = subnetIds; }
370        public List<String> getSecurityGroupIds() { return securityGroupIds; }
371        public void setSecurityGroupIds(List<String> securityGroupIds) { this.securityGroupIds = securityGroupIds; }
372        public String getVpcId() { return vpcId; }
373        public void setVpcId(String vpcId) { this.vpcId = vpcId; }
374        public String getEnvironment() { return environment; }
375        public void setEnvironment(String environment) { this.environment = environment; }
376        public String getApplicationName() { return applicationName; }
377        public void setApplicationName(String applicationName) { this.applicationName = applicationName; }
378        public int getTargetPort() { return targetPort; }
379        public void setTargetPort(int targetPort) { this.targetPort = targetPort; }
380        public TargetTypeEnum getTargetType() { return targetType; }
381        public void setTargetType(TargetTypeEnum targetType) { this.targetType = targetType; }
382        public String getSslCertificateArn() { return sslCertificateArn; }
383        public void setSslCertificateArn(String sslCertificateArn) { this.sslCertificateArn = sslCertificateArn; }
384        public String getSslPolicy() { return sslPolicy; }
385        public void setSslPolicy(String sslPolicy) { this.sslPolicy = sslPolicy; }
386        public HealthCheckConfig getHealthCheckConfig() { return healthCheckConfig; }
387        public void setHealthCheckConfig(HealthCheckConfig healthCheckConfig) { this.healthCheckConfig = healthCheckConfig; }
388    }
389
390    public static class HealthCheckConfig {
391        private String path = "/health";
392        private int interval = 30;
393        private int timeout = 5;
394        private int healthyThreshold = 5;
395        private int unhealthyThreshold = 2;
396        private String successCodes = "200";
397
398        // Constructors, getters, setters
399        public HealthCheckConfig() {}
400
401        public String getPath() { return path; }
402        public void setPath(String path) { this.path = path; }
403        public int getInterval() { return interval; }
404        public void setInterval(int interval) { this.interval = interval; }
405        public int getTimeout() { return timeout; }
406        public void setTimeout(int timeout) { this.timeout = timeout; }
407        public int getHealthyThreshold() { return healthyThreshold; }
408        public void setHealthyThreshold(int healthyThreshold) { this.healthyThreshold = healthyThreshold; }
409        public int getUnhealthyThreshold() { return unhealthyThreshold; }
410        public void setUnhealthyThreshold(int unhealthyThreshold) { this.unhealthyThreshold = unhealthyThreshold; }
411        public String getSuccessCodes() { return successCodes; }
412        public void setSuccessCodes(String successCodes) { this.successCodes = successCodes; }
413    }
414
415    public static class RoutingRule {
416        private String pathPattern;
417        private String hostHeader;
418        private KeyValue httpHeader;
419        private KeyValue queryString;
420        private ActionType actionType;
421        private String targetGroupArn;
422        private RedirectConfig redirectConfig;
423        private FixedResponseConfig fixedResponse;
424        private List<WeightedTarget> weightedTargets;
425
426        public enum ActionType {
427            FORWARD, REDIRECT, FIXED_RESPONSE, WEIGHTED_FORWARD
428        }
429
430        // Constructors, getters, setters
431        public RoutingRule() {}
432
433        public String getPathPattern() { return pathPattern; }
434        public void setPathPattern(String pathPattern) { this.pathPattern = pathPattern; }
435        public String getHostHeader() { return hostHeader; }
436        public void setHostHeader(String hostHeader) { this.hostHeader = hostHeader; }
437        public KeyValue getHttpHeader() { return httpHeader; }
438        public void setHttpHeader(KeyValue httpHeader) { this.httpHeader = httpHeader; }
439        public KeyValue getQueryString() { return queryString; }
440        public void setQueryString(KeyValue queryString) { this.queryString = queryString; }
441        public ActionType getActionType() { return actionType; }
442        public void setActionType(ActionType actionType) { this.actionType = actionType; }
443        public String getTargetGroupArn() { return targetGroupArn; }
444        public void setTargetGroupArn(String targetGroupArn) { this.targetGroupArn = targetGroupArn; }
445        public RedirectConfig getRedirectConfig() { return redirectConfig; }
446        public void setRedirectConfig(RedirectConfig redirectConfig) { this.redirectConfig = redirectConfig; }
447        public FixedResponseConfig getFixedResponse() { return fixedResponse; }
448        public void setFixedResponse(FixedResponseConfig fixedResponse) { this.fixedResponse = fixedResponse; }
449        public List<WeightedTarget> getWeightedTargets() { return weightedTargets; }
450        public void setWeightedTargets(List<WeightedTarget> weightedTargets) { this.weightedTargets = weightedTargets; }
451    }
452
453    // Additional supporting classes...
454    public static class KeyValue {
455        private String key;
456        private String value;
457
458        public KeyValue() {}
459        public KeyValue(String key, String value) { this.key = key; this.value = value; }
460
461        public String getKey() { return key; }
462        public void setKey(String key) { this.key = key; }
463        public String getValue() { return value; }
464        public void setValue(String value) { this.value = value; }
465    }
466
467    public static class RedirectConfig {
468        private String protocol = "HTTPS";
469        private String host = "#{host}";
470        private String port = "443";
471        private String path = "/#{path}";
472        private String statusCode = "301";
473
474        // Constructors, getters, setters
475        public RedirectConfig() {}
476
477        public String getProtocol() { return protocol; }
478        public void setProtocol(String protocol) { this.protocol = protocol; }
479        public String getHost() { return host; }
480        public void setHost(String host) { this.host = host; }
481        public String getPort() { return port; }
482        public void setPort(String port) { this.port = port; }
483        public String getPath() { return path; }
484        public void setPath(String path) { this.path = path; }
485        public String getStatusCode() { return statusCode; }
486        public void setStatusCode(String statusCode) { this.statusCode = statusCode; }
487    }
488
489    public static class FixedResponseConfig {
490        private String statusCode = "200";
491        private String contentType = "text/plain";
492        private String messageBody = "OK";
493
494        // Constructors, getters, setters
495        public FixedResponseConfig() {}
496
497        public String getStatusCode() { return statusCode; }
498        public void setStatusCode(String statusCode) { this.statusCode = statusCode; }
499        public String getContentType() { return contentType; }
500        public void setContentType(String contentType) { this.contentType = contentType; }
501        public String getMessageBody() { return messageBody; }
502        public void setMessageBody(String messageBody) { this.messageBody = messageBody; }
503    }
504
505    public static class WeightedTarget {
506        private String targetGroupArn;
507        private Integer weight;
508
509        public WeightedTarget() {}
510        public WeightedTarget(String targetGroupArn, Integer weight) {
511            this.targetGroupArn = targetGroupArn;
512            this.weight = weight;
513        }
514
515        public String getTargetGroupArn() { return targetGroupArn; }
516        public void setTargetGroupArn(String targetGroupArn) { this.targetGroupArn = targetGroupArn; }
517        public Integer getWeight() { return weight; }
518        public void setWeight(Integer weight) { this.weight = weight; }
519    }
520}

  1@Service
  2@Slf4j
  3public class NetworkLoadBalancerService {
  4
  5    private final ElasticLoadBalancingV2Client elbClient;
  6    private final Ec2Client ec2Client;
  7
  8    public NetworkLoadBalancerService() {
  9        this.elbClient = ElasticLoadBalancingV2Client.builder().build();
 10        this.ec2Client = Ec2Client.builder().build();
 11    }
 12
 13    public String createNetworkLoadBalancer(NLBConfiguration config) {
 14        try {
 15            // 1. Allocate Elastic IPs if needed
 16            List<String> allocationIds = new ArrayList<>();
 17            if (config.isUseStaticIps()) {
 18                allocationIds = allocateElasticIPs(config.getSubnetIds().size());
 19            }
 20
 21            // 2. Create load balancer
 22            CreateLoadBalancerRequest.Builder requestBuilder = CreateLoadBalancerRequest.builder()
 23                .name(config.getName())
 24                .scheme(config.isInternetFacing() ? Scheme.INTERNET_FACING : Scheme.INTERNAL)
 25                .type(LoadBalancerTypeEnum.NETWORK)
 26                .ipAddressType(config.getIpAddressType());
 27
 28            // Configure subnets with static IPs if specified
 29            if (config.isUseStaticIps() && !allocationIds.isEmpty()) {
 30                List<SubnetMapping> subnetMappings = new ArrayList<>();
 31                for (int i = 0; i < config.getSubnetIds().size(); i++) {
 32                    subnetMappings.add(SubnetMapping.builder()
 33                        .subnetId(config.getSubnetIds().get(i))
 34                        .allocationId(i < allocationIds.size() ? allocationIds.get(i) : null)
 35                        .build());
 36                }
 37                requestBuilder.subnetMappings(subnetMappings);
 38            } else {
 39                requestBuilder.subnets(config.getSubnetIds());
 40            }
 41
 42            requestBuilder.tags(
 43                Tag.builder().key("Environment").value(config.getEnvironment()).build(),
 44                Tag.builder().key("Application").value(config.getApplicationName()).build(),
 45                Tag.builder().key("Type").value("NetworkLoadBalancer").build()
 46            );
 47
 48            CreateLoadBalancerResponse response = elbClient.createLoadBalancer(requestBuilder.build());
 49            String loadBalancerArn = response.loadBalancers().get(0).loadBalancerArn();
 50
 51            log.info("Created Network Load Balancer: {} with ARN: {}", config.getName(), loadBalancerArn);
 52
 53            // 3. Create target group
 54            String targetGroupArn = createNLBTargetGroup(config);
 55
 56            // 4. Create listener
 57            createNLBListener(loadBalancerArn, targetGroupArn, config);
 58
 59            return loadBalancerArn;
 60
 61        } catch (Exception e) {
 62            log.error("Failed to create Network Load Balancer: {}", config.getName(), e);
 63            throw new RuntimeException("NLB creation failed", e);
 64        }
 65    }
 66
 67    private List<String> allocateElasticIPs(int count) {
 68        List<String> allocationIds = new ArrayList<>();
 69
 70        for (int i = 0; i < count; i++) {
 71            try {
 72                AllocateAddressRequest request = AllocateAddressRequest.builder()
 73                    .domain(DomainType.VPC)
 74                    .build();
 75
 76                AllocateAddressResponse response = ec2Client.allocateAddress(request);
 77                allocationIds.add(response.allocationId());
 78
 79                log.info("Allocated Elastic IP: {} ({})", response.publicIp(), response.allocationId());
 80
 81            } catch (Exception e) {
 82                log.error("Failed to allocate Elastic IP", e);
 83                throw new RuntimeException("Elastic IP allocation failed", e);
 84            }
 85        }
 86
 87        return allocationIds;
 88    }
 89
 90    private String createNLBTargetGroup(NLBConfiguration config) {
 91        try {
 92            CreateTargetGroupRequest.Builder requestBuilder = CreateTargetGroupRequest.builder()
 93                .name(config.getName() + "-nlb-tg")
 94                .protocol(ProtocolEnum.fromValue(config.getProtocol().toUpperCase()))
 95                .port(config.getTargetPort())
 96                .vpcId(config.getVpcId())
 97                .targetType(config.getTargetType())
 98                .healthCheckEnabled(true)
 99                .healthCheckProtocol(ProtocolEnum.fromValue(config.getHealthCheckProtocol().toUpperCase()))
100                .healthCheckPort("traffic-port")
101                .healthCheckIntervalSeconds(config.getHealthCheckInterval())
102                .healthyThresholdCount(config.getHealthyThreshold())
103                .unhealthyThresholdCount(config.getUnhealthyThreshold());
104
105            // Configure health check path for HTTP/HTTPS
106            if (config.getHealthCheckProtocol().equalsIgnoreCase("HTTP") ||
107                config.getHealthCheckProtocol().equalsIgnoreCase("HTTPS")) {
108                requestBuilder.healthCheckPath(config.getHealthCheckPath());
109            }
110
111            // Configure deregistration delay
112            requestBuilder.targetGroupAttributes(
113                TargetGroupAttribute.builder()
114                    .key("deregistration_delay.timeout_seconds")
115                    .value(String.valueOf(config.getDeregistrationDelay()))
116                    .build(),
117                TargetGroupAttribute.builder()
118                    .key("preserve_client_ip.enabled")
119                    .value(String.valueOf(config.isPreserveClientIp()))
120                    .build(),
121                TargetGroupAttribute.builder()
122                    .key("proxy_protocol_v2.enabled")
123                    .value(String.valueOf(config.isProxyProtocolV2()))
124                    .build()
125            );
126
127            CreateTargetGroupResponse response = elbClient.createTargetGroup(requestBuilder.build());
128            String targetGroupArn = response.targetGroups().get(0).targetGroupArn();
129
130            log.info("Created NLB target group: {} with ARN: {}", config.getName() + "-nlb-tg", targetGroupArn);
131            return targetGroupArn;
132
133        } catch (Exception e) {
134            log.error("Failed to create NLB target group for: {}", config.getName(), e);
135            throw new RuntimeException("NLB target group creation failed", e);
136        }
137    }
138
139    private void createNLBListener(String loadBalancerArn, String targetGroupArn, NLBConfiguration config) {
140        try {
141            CreateListenerRequest.Builder requestBuilder = CreateListenerRequest.builder()
142                .loadBalancerArn(loadBalancerArn)
143                .protocol(ProtocolEnum.fromValue(config.getProtocol().toUpperCase()))
144                .port(config.getListenerPort())
145                .defaultActions(Action.builder()
146                    .type(ActionTypeEnum.FORWARD)
147                    .targetGroupArn(targetGroupArn)
148                    .build());
149
150            // Add TLS configuration if needed
151            if (config.getProtocol().equalsIgnoreCase("TLS") && config.getSslCertificateArn() != null) {
152                requestBuilder.certificates(Certificate.builder()
153                    .certificateArn(config.getSslCertificateArn())
154                    .build());
155                requestBuilder.sslPolicy(config.getSslPolicy());
156            }
157
158            elbClient.createListener(requestBuilder.build());
159            log.info("Created NLB listener for port {} with protocol {}", config.getListenerPort(), config.getProtocol());
160
161        } catch (Exception e) {
162            log.error("Failed to create NLB listener for: {}", loadBalancerArn, e);
163            throw new RuntimeException("NLB listener creation failed", e);
164        }
165    }
166
167    public void enableCrossZoneLoadBalancing(String loadBalancerArn, boolean enabled) {
168        try {
169            ModifyLoadBalancerAttributesRequest request = ModifyLoadBalancerAttributesRequest.builder()
170                .loadBalancerArn(loadBalancerArn)
171                .attributes(LoadBalancerAttribute.builder()
172                    .key("load_balancing.cross_zone.enabled")
173                    .value(String.valueOf(enabled))
174                    .build())
175                .build();
176
177            elbClient.modifyLoadBalancerAttributes(request);
178            log.info("Cross-zone load balancing {} for NLB: {}",
179                enabled ? "enabled" : "disabled", loadBalancerArn);
180
181        } catch (Exception e) {
182            log.error("Failed to modify cross-zone load balancing for NLB: {}", loadBalancerArn, e);
183            throw new RuntimeException("Cross-zone configuration failed", e);
184        }
185    }
186
187    public void configureConnectionIdle(String loadBalancerArn, int idleTimeoutSeconds) {
188        try {
189            ModifyLoadBalancerAttributesRequest request = ModifyLoadBalancerAttributesRequest.builder()
190                .loadBalancerArn(loadBalancerArn)
191                .attributes(LoadBalancerAttribute.builder()
192                    .key("idle_timeout.timeout_seconds")
193                    .value(String.valueOf(idleTimeoutSeconds))
194                    .build())
195                .build();
196
197            elbClient.modifyLoadBalancerAttributes(request);
198            log.info("Configured idle timeout to {} seconds for NLB: {}", idleTimeoutSeconds, loadBalancerArn);
199
200        } catch (Exception e) {
201            log.error("Failed to configure idle timeout for NLB: {}", loadBalancerArn, e);
202            throw new RuntimeException("Idle timeout configuration failed", e);
203        }
204    }
205
206    // NLB Configuration class
207    public static class NLBConfiguration {
208        private String name;
209        private boolean internetFacing = true;
210        private IpAddressType ipAddressType = IpAddressType.IPV4;
211        private List<String> subnetIds;
212        private String vpcId;
213        private String environment = "production";
214        private String applicationName;
215        private String protocol = "TCP";
216        private int listenerPort = 80;
217        private int targetPort = 8080;
218        private TargetTypeEnum targetType = TargetTypeEnum.INSTANCE;
219        private boolean useStaticIps = false;
220        private String healthCheckProtocol = "TCP";
221        private String healthCheckPath = "/";
222        private int healthCheckInterval = 30;
223        private int healthyThreshold = 3;
224        private int unhealthyThreshold = 3;
225        private int deregistrationDelay = 300;
226        private boolean preserveClientIp = false;
227        private boolean proxyProtocolV2 = false;
228        private String sslCertificateArn;
229        private String sslPolicy = "ELBSecurityPolicy-TLS-1-2-2017-01";
230
231        // Constructors, getters, setters
232        public NLBConfiguration() {}
233
234        public NLBConfiguration(String name, List<String> subnetIds, String vpcId) {
235            this.name = name;
236            this.subnetIds = subnetIds;
237            this.vpcId = vpcId;
238        }
239
240        // All getters and setters
241        public String getName() { return name; }
242        public void setName(String name) { this.name = name; }
243        public boolean isInternetFacing() { return internetFacing; }
244        public void setInternetFacing(boolean internetFacing) { this.internetFacing = internetFacing; }
245        public IpAddressType getIpAddressType() { return ipAddressType; }
246        public void setIpAddressType(IpAddressType ipAddressType) { this.ipAddressType = ipAddressType; }
247        public List<String> getSubnetIds() { return subnetIds; }
248        public void setSubnetIds(List<String> subnetIds) { this.subnetIds = subnetIds; }
249        public String getVpcId() { return vpcId; }
250        public void setVpcId(String vpcId) { this.vpcId = vpcId; }
251        public String getEnvironment() { return environment; }
252        public void setEnvironment(String environment) { this.environment = environment; }
253        public String getApplicationName() { return applicationName; }
254        public void setApplicationName(String applicationName) { this.applicationName = applicationName; }
255        public String getProtocol() { return protocol; }
256        public void setProtocol(String protocol) { this.protocol = protocol; }
257        public int getListenerPort() { return listenerPort; }
258        public void setListenerPort(int listenerPort) { this.listenerPort = listenerPort; }
259        public int getTargetPort() { return targetPort; }
260        public void setTargetPort(int targetPort) { this.targetPort = targetPort; }
261        public TargetTypeEnum getTargetType() { return targetType; }
262        public void setTargetType(TargetTypeEnum targetType) { this.targetType = targetType; }
263        public boolean isUseStaticIps() { return useStaticIps; }
264        public void setUseStaticIps(boolean useStaticIps) { this.useStaticIps = useStaticIps; }
265        public String getHealthCheckProtocol() { return healthCheckProtocol; }
266        public void setHealthCheckProtocol(String healthCheckProtocol) { this.healthCheckProtocol = healthCheckProtocol; }
267        public String getHealthCheckPath() { return healthCheckPath; }
268        public void setHealthCheckPath(String healthCheckPath) { this.healthCheckPath = healthCheckPath; }
269        public int getHealthCheckInterval() { return healthCheckInterval; }
270        public void setHealthCheckInterval(int healthCheckInterval) { this.healthCheckInterval = healthCheckInterval; }
271        public int getHealthyThreshold() { return healthyThreshold; }
272        public void setHealthyThreshold(int healthyThreshold) { this.healthyThreshold = healthyThreshold; }
273        public int getUnhealthyThreshold() { return unhealthyThreshold; }
274        public void setUnhealthyThreshold(int unhealthyThreshold) { this.unhealthyThreshold = unhealthyThreshold; }
275        public int getDeregistrationDelay() { return deregistrationDelay; }
276        public void setDeregistrationDelay(int deregistrationDelay) { this.deregistrationDelay = deregistrationDelay; }
277        public boolean isPreserveClientIp() { return preserveClientIp; }
278        public void setPreserveClientIp(boolean preserveClientIp) { this.preserveClientIp = preserveClientIp; }
279        public boolean isProxyProtocolV2() { return proxyProtocolV2; }
280        public void setProxyProtocolV2(boolean proxyProtocolV2) { this.proxyProtocolV2 = proxyProtocolV2; }
281        public String getSslCertificateArn() { return sslCertificateArn; }
282        public void setSslCertificateArn(String sslCertificateArn) { this.sslCertificateArn = sslCertificateArn; }
283        public String getSslPolicy() { return sslPolicy; }
284        public void setSslPolicy(String sslPolicy) { this.sslPolicy = sslPolicy; }
285    }
286}