@pulumi/awsx 2.7.0 → 2.9.0-alpha.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (34) hide show
  1. package/README.md +17 -1
  2. package/ec2/getDefaultVpc.d.ts +1 -1
  3. package/ec2/getDefaultVpc.js +3 -1
  4. package/ec2/getDefaultVpc.js.map +1 -1
  5. package/ec2/vpc.d.ts +2 -2
  6. package/ecr/image.d.ts +4 -0
  7. package/ecr/image.js +1 -0
  8. package/ecr/image.js.map +1 -1
  9. package/ecs/ec2service.d.ts +22 -5
  10. package/ecs/ec2service.js +4 -0
  11. package/ecs/ec2service.js.map +1 -1
  12. package/ecs/ec2taskDefinition.d.ts +4 -0
  13. package/ecs/ec2taskDefinition.js +1 -0
  14. package/ecs/ec2taskDefinition.js.map +1 -1
  15. package/ecs/fargateService.d.ts +22 -5
  16. package/ecs/fargateService.js +4 -0
  17. package/ecs/fargateService.js.map +1 -1
  18. package/ecs/fargateTaskDefinition.d.ts +4 -0
  19. package/ecs/fargateTaskDefinition.js +1 -0
  20. package/ecs/fargateTaskDefinition.js.map +1 -1
  21. package/lb/applicationLoadBalancer.d.ts +33 -21
  22. package/lb/applicationLoadBalancer.js +4 -0
  23. package/lb/applicationLoadBalancer.js.map +1 -1
  24. package/lb/networkLoadBalancer.d.ts +35 -19
  25. package/lb/networkLoadBalancer.js +5 -0
  26. package/lb/networkLoadBalancer.js.map +1 -1
  27. package/package.json +7 -8
  28. package/types/input.d.ts +991 -367
  29. package/types/input.js.map +1 -1
  30. package/utilities.d.ts +4 -0
  31. package/utilities.js +33 -1
  32. package/utilities.js.map +1 -1
  33. package/package.json.dev +0 -36
  34. package/scripts/install-pulumi-plugin.js +0 -21
package/types/input.d.ts CHANGED
@@ -194,6 +194,10 @@ export declare namespace awsx {
194
194
  * permissions for the CMK whenever the encrypted data is requested.
195
195
  */
196
196
  kmsKeyId?: pulumi.Input<string>;
197
+ /**
198
+ * Specified the log class of the log group. Possible values are: `STANDARD` or `INFREQUENT_ACCESS`.
199
+ */
200
+ logGroupClass?: pulumi.Input<string>;
197
201
  /**
198
202
  * The name of the log group. If omitted, this provider will assign a random, unique name.
199
203
  */
@@ -262,9 +266,12 @@ export declare namespace awsx {
262
266
  */
263
267
  forceDetachPolicies?: pulumi.Input<boolean>;
264
268
  /**
265
- * Configuration block defining an exclusive set of IAM inline policies associated with the IAM role. See below. If no blocks are configured, the provider will not manage any inline policies in this resource. Configuring one empty block (i.e., `inline_policy {}`) will cause the provider to remove _all_ inline policies added out of band on `apply`.
269
+ * Configuration block defining an exclusive set of IAM inline policies associated with the IAM role. See below. If no blocks are configured, Pulumi will not manage any inline policies in this resource. Configuring one empty block (i.e., `inline_policy {}`) will cause Pulumi to remove _all_ inline policies added out of band on `apply`.
266
270
  */
267
271
  inlinePolicies?: pulumi.Input<pulumi.Input<pulumiAws.types.input.iam.RoleInlinePolicy>[]>;
272
+ /**
273
+ * Set of exclusive IAM managed policy ARNs to attach to the IAM role. If this attribute is not configured, Pulumi will ignore policy attachments to this resource. When configured, Pulumi will align the role's managed policy attachments with this set by attaching or detaching managed policies. Configuring an empty set (i.e., `managed_policy_arns = []`) will cause Pulumi to remove _all_ managed policy attachments.
274
+ */
268
275
  managedPolicyArns?: pulumi.Input<pulumi.Input<string>[]>;
269
276
  /**
270
277
  * Maximum session duration (in seconds) that you want to set for the specified role. If you do not specify a value for this setting, the default maximum of one hour is applied. This setting can have a value from 1 hour to 12 hours.
@@ -399,17 +406,17 @@ export declare namespace ec2 {
399
406
  * Do not use the same resource ID in both a VPC Endpoint resource and a VPC Endpoint Association resource.
400
407
  * Doing so will cause a conflict of associations and will overwrite the association.
401
408
  *
402
- * {{% examples %}}
403
409
  * ## Example Usage
404
- * {{% example %}}
410
+ *
405
411
  * ### Basic
406
412
  *
413
+ * <!--Start PulumiCodeChooser -->
407
414
  * ```typescript
408
415
  * import * as pulumi from "@pulumi/pulumi";
409
416
  * import * as aws from "@pulumi/aws";
410
417
  *
411
418
  * const s3 = new aws.ec2.VpcEndpoint("s3", {
412
- * vpcId: aws_vpc.main.id,
419
+ * vpcId: main.id,
413
420
  * serviceName: "com.amazonaws.us-west-2.s3",
414
421
  * });
415
422
  * ```
@@ -418,7 +425,7 @@ export declare namespace ec2 {
418
425
  * import pulumi_aws as aws
419
426
  *
420
427
  * s3 = aws.ec2.VpcEndpoint("s3",
421
- * vpc_id=aws_vpc["main"]["id"],
428
+ * vpc_id=main["id"],
422
429
  * service_name="com.amazonaws.us-west-2.s3")
423
430
  * ```
424
431
  * ```csharp
@@ -431,7 +438,7 @@ export declare namespace ec2 {
431
438
  * {
432
439
  * var s3 = new Aws.Ec2.VpcEndpoint("s3", new()
433
440
  * {
434
- * VpcId = aws_vpc.Main.Id,
441
+ * VpcId = main.Id,
435
442
  * ServiceName = "com.amazonaws.us-west-2.s3",
436
443
  * });
437
444
  *
@@ -448,7 +455,7 @@ export declare namespace ec2 {
448
455
  * func main() {
449
456
  * pulumi.Run(func(ctx *pulumi.Context) error {
450
457
  * _, err := ec2.NewVpcEndpoint(ctx, "s3", &ec2.VpcEndpointArgs{
451
- * VpcId: pulumi.Any(aws_vpc.Main.Id),
458
+ * VpcId: pulumi.Any(main.Id),
452
459
  * ServiceName: pulumi.String("com.amazonaws.us-west-2.s3"),
453
460
  * })
454
461
  * if err != nil {
@@ -480,7 +487,7 @@ export declare namespace ec2 {
480
487
  *
481
488
  * public static void stack(Context ctx) {
482
489
  * var s3 = new VpcEndpoint("s3", VpcEndpointArgs.builder()
483
- * .vpcId(aws_vpc.main().id())
490
+ * .vpcId(main.id())
484
491
  * .serviceName("com.amazonaws.us-west-2.s3")
485
492
  * .build());
486
493
  *
@@ -492,19 +499,20 @@ export declare namespace ec2 {
492
499
  * s3:
493
500
  * type: aws:ec2:VpcEndpoint
494
501
  * properties:
495
- * vpcId: ${aws_vpc.main.id}
502
+ * vpcId: ${main.id}
496
503
  * serviceName: com.amazonaws.us-west-2.s3
497
504
  * ```
498
- * {{% /example %}}
499
- * {{% example %}}
505
+ * <!--End PulumiCodeChooser -->
506
+ *
500
507
  * ### Basic w/ Tags
501
508
  *
509
+ * <!--Start PulumiCodeChooser -->
502
510
  * ```typescript
503
511
  * import * as pulumi from "@pulumi/pulumi";
504
512
  * import * as aws from "@pulumi/aws";
505
513
  *
506
514
  * const s3 = new aws.ec2.VpcEndpoint("s3", {
507
- * vpcId: aws_vpc.main.id,
515
+ * vpcId: main.id,
508
516
  * serviceName: "com.amazonaws.us-west-2.s3",
509
517
  * tags: {
510
518
  * Environment: "test",
@@ -516,7 +524,7 @@ export declare namespace ec2 {
516
524
  * import pulumi_aws as aws
517
525
  *
518
526
  * s3 = aws.ec2.VpcEndpoint("s3",
519
- * vpc_id=aws_vpc["main"]["id"],
527
+ * vpc_id=main["id"],
520
528
  * service_name="com.amazonaws.us-west-2.s3",
521
529
  * tags={
522
530
  * "Environment": "test",
@@ -532,7 +540,7 @@ export declare namespace ec2 {
532
540
  * {
533
541
  * var s3 = new Aws.Ec2.VpcEndpoint("s3", new()
534
542
  * {
535
- * VpcId = aws_vpc.Main.Id,
543
+ * VpcId = main.Id,
536
544
  * ServiceName = "com.amazonaws.us-west-2.s3",
537
545
  * Tags =
538
546
  * {
@@ -553,7 +561,7 @@ export declare namespace ec2 {
553
561
  * func main() {
554
562
  * pulumi.Run(func(ctx *pulumi.Context) error {
555
563
  * _, err := ec2.NewVpcEndpoint(ctx, "s3", &ec2.VpcEndpointArgs{
556
- * VpcId: pulumi.Any(aws_vpc.Main.Id),
564
+ * VpcId: pulumi.Any(main.Id),
557
565
  * ServiceName: pulumi.String("com.amazonaws.us-west-2.s3"),
558
566
  * Tags: pulumi.StringMap{
559
567
  * "Environment": pulumi.String("test"),
@@ -588,7 +596,7 @@ export declare namespace ec2 {
588
596
  *
589
597
  * public static void stack(Context ctx) {
590
598
  * var s3 = new VpcEndpoint("s3", VpcEndpointArgs.builder()
591
- * .vpcId(aws_vpc.main().id())
599
+ * .vpcId(main.id())
592
600
  * .serviceName("com.amazonaws.us-west-2.s3")
593
601
  * .tags(Map.of("Environment", "test"))
594
602
  * .build());
@@ -601,24 +609,25 @@ export declare namespace ec2 {
601
609
  * s3:
602
610
  * type: aws:ec2:VpcEndpoint
603
611
  * properties:
604
- * vpcId: ${aws_vpc.main.id}
612
+ * vpcId: ${main.id}
605
613
  * serviceName: com.amazonaws.us-west-2.s3
606
614
  * tags:
607
615
  * Environment: test
608
616
  * ```
609
- * {{% /example %}}
610
- * {{% example %}}
617
+ * <!--End PulumiCodeChooser -->
618
+ *
611
619
  * ### Interface Endpoint Type
612
620
  *
621
+ * <!--Start PulumiCodeChooser -->
613
622
  * ```typescript
614
623
  * import * as pulumi from "@pulumi/pulumi";
615
624
  * import * as aws from "@pulumi/aws";
616
625
  *
617
626
  * const ec2 = new aws.ec2.VpcEndpoint("ec2", {
618
- * vpcId: aws_vpc.main.id,
627
+ * vpcId: main.id,
619
628
  * serviceName: "com.amazonaws.us-west-2.ec2",
620
629
  * vpcEndpointType: "Interface",
621
- * securityGroupIds: [aws_security_group.sg1.id],
630
+ * securityGroupIds: [sg1.id],
622
631
  * privateDnsEnabled: true,
623
632
  * });
624
633
  * ```
@@ -627,10 +636,10 @@ export declare namespace ec2 {
627
636
  * import pulumi_aws as aws
628
637
  *
629
638
  * ec2 = aws.ec2.VpcEndpoint("ec2",
630
- * vpc_id=aws_vpc["main"]["id"],
639
+ * vpc_id=main["id"],
631
640
  * service_name="com.amazonaws.us-west-2.ec2",
632
641
  * vpc_endpoint_type="Interface",
633
- * security_group_ids=[aws_security_group["sg1"]["id"]],
642
+ * security_group_ids=[sg1["id"]],
634
643
  * private_dns_enabled=True)
635
644
  * ```
636
645
  * ```csharp
@@ -643,12 +652,12 @@ export declare namespace ec2 {
643
652
  * {
644
653
  * var ec2 = new Aws.Ec2.VpcEndpoint("ec2", new()
645
654
  * {
646
- * VpcId = aws_vpc.Main.Id,
655
+ * VpcId = main.Id,
647
656
  * ServiceName = "com.amazonaws.us-west-2.ec2",
648
657
  * VpcEndpointType = "Interface",
649
658
  * SecurityGroupIds = new[]
650
659
  * {
651
- * aws_security_group.Sg1.Id,
660
+ * sg1.Id,
652
661
  * },
653
662
  * PrivateDnsEnabled = true,
654
663
  * });
@@ -666,11 +675,11 @@ export declare namespace ec2 {
666
675
  * func main() {
667
676
  * pulumi.Run(func(ctx *pulumi.Context) error {
668
677
  * _, err := ec2.NewVpcEndpoint(ctx, "ec2", &ec2.VpcEndpointArgs{
669
- * VpcId: pulumi.Any(aws_vpc.Main.Id),
678
+ * VpcId: pulumi.Any(main.Id),
670
679
  * ServiceName: pulumi.String("com.amazonaws.us-west-2.ec2"),
671
680
  * VpcEndpointType: pulumi.String("Interface"),
672
681
  * SecurityGroupIds: pulumi.StringArray{
673
- * aws_security_group.Sg1.Id,
682
+ * sg1.Id,
674
683
  * },
675
684
  * PrivateDnsEnabled: pulumi.Bool(true),
676
685
  * })
@@ -703,10 +712,10 @@ export declare namespace ec2 {
703
712
  *
704
713
  * public static void stack(Context ctx) {
705
714
  * var ec2 = new VpcEndpoint("ec2", VpcEndpointArgs.builder()
706
- * .vpcId(aws_vpc.main().id())
715
+ * .vpcId(main.id())
707
716
  * .serviceName("com.amazonaws.us-west-2.ec2")
708
717
  * .vpcEndpointType("Interface")
709
- * .securityGroupIds(aws_security_group.sg1().id())
718
+ * .securityGroupIds(sg1.id())
710
719
  * .privateDnsEnabled(true)
711
720
  * .build());
712
721
  *
@@ -718,32 +727,216 @@ export declare namespace ec2 {
718
727
  * ec2:
719
728
  * type: aws:ec2:VpcEndpoint
720
729
  * properties:
721
- * vpcId: ${aws_vpc.main.id}
730
+ * vpcId: ${main.id}
722
731
  * serviceName: com.amazonaws.us-west-2.ec2
723
732
  * vpcEndpointType: Interface
724
733
  * securityGroupIds:
725
- * - ${aws_security_group.sg1.id}
734
+ * - ${sg1.id}
726
735
  * privateDnsEnabled: true
727
736
  * ```
728
- * {{% /example %}}
729
- * {{% example %}}
737
+ * <!--End PulumiCodeChooser -->
738
+ *
739
+ * ### Interface Endpoint Type with User-Defined IP Address
740
+ *
741
+ * <!--Start PulumiCodeChooser -->
742
+ * ```typescript
743
+ * import * as pulumi from "@pulumi/pulumi";
744
+ * import * as aws from "@pulumi/aws";
745
+ *
746
+ * const ec2 = new aws.ec2.VpcEndpoint("ec2", {
747
+ * vpcId: example.id,
748
+ * serviceName: "com.amazonaws.us-west-2.ec2",
749
+ * vpcEndpointType: "Interface",
750
+ * subnetConfigurations: [
751
+ * {
752
+ * ipv4: "10.0.1.10",
753
+ * subnetId: example1.id,
754
+ * },
755
+ * {
756
+ * ipv4: "10.0.2.10",
757
+ * subnetId: example2.id,
758
+ * },
759
+ * ],
760
+ * subnetIds: [
761
+ * example1.id,
762
+ * example2.id,
763
+ * ],
764
+ * });
765
+ * ```
766
+ * ```python
767
+ * import pulumi
768
+ * import pulumi_aws as aws
769
+ *
770
+ * ec2 = aws.ec2.VpcEndpoint("ec2",
771
+ * vpc_id=example["id"],
772
+ * service_name="com.amazonaws.us-west-2.ec2",
773
+ * vpc_endpoint_type="Interface",
774
+ * subnet_configurations=[
775
+ * {
776
+ * "ipv4": "10.0.1.10",
777
+ * "subnet_id": example1["id"],
778
+ * },
779
+ * {
780
+ * "ipv4": "10.0.2.10",
781
+ * "subnet_id": example2["id"],
782
+ * },
783
+ * ],
784
+ * subnet_ids=[
785
+ * example1["id"],
786
+ * example2["id"],
787
+ * ])
788
+ * ```
789
+ * ```csharp
790
+ * using System.Collections.Generic;
791
+ * using System.Linq;
792
+ * using Pulumi;
793
+ * using Aws = Pulumi.Aws;
794
+ *
795
+ * return await Deployment.RunAsync(() =>
796
+ * {
797
+ * var ec2 = new Aws.Ec2.VpcEndpoint("ec2", new()
798
+ * {
799
+ * VpcId = example.Id,
800
+ * ServiceName = "com.amazonaws.us-west-2.ec2",
801
+ * VpcEndpointType = "Interface",
802
+ * SubnetConfigurations = new[]
803
+ * {
804
+ * new Aws.Ec2.Inputs.VpcEndpointSubnetConfigurationArgs
805
+ * {
806
+ * Ipv4 = "10.0.1.10",
807
+ * SubnetId = example1.Id,
808
+ * },
809
+ * new Aws.Ec2.Inputs.VpcEndpointSubnetConfigurationArgs
810
+ * {
811
+ * Ipv4 = "10.0.2.10",
812
+ * SubnetId = example2.Id,
813
+ * },
814
+ * },
815
+ * SubnetIds = new[]
816
+ * {
817
+ * example1.Id,
818
+ * example2.Id,
819
+ * },
820
+ * });
821
+ *
822
+ * });
823
+ * ```
824
+ * ```go
825
+ * package main
826
+ *
827
+ * import (
828
+ * "github.com/pulumi/pulumi-aws/sdk/v6/go/aws/ec2"
829
+ * "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
830
+ * )
831
+ *
832
+ * func main() {
833
+ * pulumi.Run(func(ctx *pulumi.Context) error {
834
+ * _, err := ec2.NewVpcEndpoint(ctx, "ec2", &ec2.VpcEndpointArgs{
835
+ * VpcId: pulumi.Any(example.Id),
836
+ * ServiceName: pulumi.String("com.amazonaws.us-west-2.ec2"),
837
+ * VpcEndpointType: pulumi.String("Interface"),
838
+ * SubnetConfigurations: ec2.VpcEndpointSubnetConfigurationArray{
839
+ * &ec2.VpcEndpointSubnetConfigurationArgs{
840
+ * Ipv4: pulumi.String("10.0.1.10"),
841
+ * SubnetId: pulumi.Any(example1.Id),
842
+ * },
843
+ * &ec2.VpcEndpointSubnetConfigurationArgs{
844
+ * Ipv4: pulumi.String("10.0.2.10"),
845
+ * SubnetId: pulumi.Any(example2.Id),
846
+ * },
847
+ * },
848
+ * SubnetIds: pulumi.StringArray{
849
+ * example1.Id,
850
+ * example2.Id,
851
+ * },
852
+ * })
853
+ * if err != nil {
854
+ * return err
855
+ * }
856
+ * return nil
857
+ * })
858
+ * }
859
+ * ```
860
+ * ```java
861
+ * package generated_program;
862
+ *
863
+ * import com.pulumi.Context;
864
+ * import com.pulumi.Pulumi;
865
+ * import com.pulumi.core.Output;
866
+ * import com.pulumi.aws.ec2.VpcEndpoint;
867
+ * import com.pulumi.aws.ec2.VpcEndpointArgs;
868
+ * import com.pulumi.aws.ec2.inputs.VpcEndpointSubnetConfigurationArgs;
869
+ * import java.util.List;
870
+ * import java.util.ArrayList;
871
+ * import java.util.Map;
872
+ * import java.io.File;
873
+ * import java.nio.file.Files;
874
+ * import java.nio.file.Paths;
875
+ *
876
+ * public class App {
877
+ * public static void main(String[] args) {
878
+ * Pulumi.run(App::stack);
879
+ * }
880
+ *
881
+ * public static void stack(Context ctx) {
882
+ * var ec2 = new VpcEndpoint("ec2", VpcEndpointArgs.builder()
883
+ * .vpcId(example.id())
884
+ * .serviceName("com.amazonaws.us-west-2.ec2")
885
+ * .vpcEndpointType("Interface")
886
+ * .subnetConfigurations(
887
+ * VpcEndpointSubnetConfigurationArgs.builder()
888
+ * .ipv4("10.0.1.10")
889
+ * .subnetId(example1.id())
890
+ * .build(),
891
+ * VpcEndpointSubnetConfigurationArgs.builder()
892
+ * .ipv4("10.0.2.10")
893
+ * .subnetId(example2.id())
894
+ * .build())
895
+ * .subnetIds(
896
+ * example1.id(),
897
+ * example2.id())
898
+ * .build());
899
+ *
900
+ * }
901
+ * }
902
+ * ```
903
+ * ```yaml
904
+ * resources:
905
+ * ec2:
906
+ * type: aws:ec2:VpcEndpoint
907
+ * properties:
908
+ * vpcId: ${example.id}
909
+ * serviceName: com.amazonaws.us-west-2.ec2
910
+ * vpcEndpointType: Interface
911
+ * subnetConfigurations:
912
+ * - ipv4: 10.0.1.10
913
+ * subnetId: ${example1.id}
914
+ * - ipv4: 10.0.2.10
915
+ * subnetId: ${example2.id}
916
+ * subnetIds:
917
+ * - ${example1.id}
918
+ * - ${example2.id}
919
+ * ```
920
+ * <!--End PulumiCodeChooser -->
921
+ *
730
922
  * ### Gateway Load Balancer Endpoint Type
731
923
  *
924
+ * <!--Start PulumiCodeChooser -->
732
925
  * ```typescript
733
926
  * import * as pulumi from "@pulumi/pulumi";
734
927
  * import * as aws from "@pulumi/aws";
735
928
  *
736
929
  * const current = aws.getCallerIdentity({});
737
- * const exampleVpcEndpointService = new aws.ec2.VpcEndpointService("exampleVpcEndpointService", {
930
+ * const example = new aws.ec2.VpcEndpointService("example", {
738
931
  * acceptanceRequired: false,
739
932
  * allowedPrincipals: [current.then(current => current.arn)],
740
- * gatewayLoadBalancerArns: [aws_lb.example.arn],
933
+ * gatewayLoadBalancerArns: [exampleAwsLb.arn],
741
934
  * });
742
- * const exampleVpcEndpoint = new aws.ec2.VpcEndpoint("exampleVpcEndpoint", {
743
- * serviceName: exampleVpcEndpointService.serviceName,
744
- * subnetIds: [aws_subnet.example.id],
745
- * vpcEndpointType: exampleVpcEndpointService.serviceType,
746
- * vpcId: aws_vpc.example.id,
935
+ * const exampleVpcEndpoint = new aws.ec2.VpcEndpoint("example", {
936
+ * serviceName: example.serviceName,
937
+ * subnetIds: [exampleAwsSubnet.id],
938
+ * vpcEndpointType: example.serviceType,
939
+ * vpcId: exampleAwsVpc.id,
747
940
  * });
748
941
  * ```
749
942
  * ```python
@@ -751,15 +944,15 @@ export declare namespace ec2 {
751
944
  * import pulumi_aws as aws
752
945
  *
753
946
  * current = aws.get_caller_identity()
754
- * example_vpc_endpoint_service = aws.ec2.VpcEndpointService("exampleVpcEndpointService",
947
+ * example = aws.ec2.VpcEndpointService("example",
755
948
  * acceptance_required=False,
756
949
  * allowed_principals=[current.arn],
757
- * gateway_load_balancer_arns=[aws_lb["example"]["arn"]])
758
- * example_vpc_endpoint = aws.ec2.VpcEndpoint("exampleVpcEndpoint",
759
- * service_name=example_vpc_endpoint_service.service_name,
760
- * subnet_ids=[aws_subnet["example"]["id"]],
761
- * vpc_endpoint_type=example_vpc_endpoint_service.service_type,
762
- * vpc_id=aws_vpc["example"]["id"])
950
+ * gateway_load_balancer_arns=[example_aws_lb["arn"]])
951
+ * example_vpc_endpoint = aws.ec2.VpcEndpoint("example",
952
+ * service_name=example.service_name,
953
+ * subnet_ids=[example_aws_subnet["id"]],
954
+ * vpc_endpoint_type=example.service_type,
955
+ * vpc_id=example_aws_vpc["id"])
763
956
  * ```
764
957
  * ```csharp
765
958
  * using System.Collections.Generic;
@@ -771,7 +964,7 @@ export declare namespace ec2 {
771
964
  * {
772
965
  * var current = Aws.GetCallerIdentity.Invoke();
773
966
  *
774
- * var exampleVpcEndpointService = new Aws.Ec2.VpcEndpointService("exampleVpcEndpointService", new()
967
+ * var example = new Aws.Ec2.VpcEndpointService("example", new()
775
968
  * {
776
969
  * AcceptanceRequired = false,
777
970
  * AllowedPrincipals = new[]
@@ -780,19 +973,19 @@ export declare namespace ec2 {
780
973
  * },
781
974
  * GatewayLoadBalancerArns = new[]
782
975
  * {
783
- * aws_lb.Example.Arn,
976
+ * exampleAwsLb.Arn,
784
977
  * },
785
978
  * });
786
979
  *
787
- * var exampleVpcEndpoint = new Aws.Ec2.VpcEndpoint("exampleVpcEndpoint", new()
980
+ * var exampleVpcEndpoint = new Aws.Ec2.VpcEndpoint("example", new()
788
981
  * {
789
- * ServiceName = exampleVpcEndpointService.ServiceName,
982
+ * ServiceName = example.ServiceName,
790
983
  * SubnetIds = new[]
791
984
  * {
792
- * aws_subnet.Example.Id,
985
+ * exampleAwsSubnet.Id,
793
986
  * },
794
- * VpcEndpointType = exampleVpcEndpointService.ServiceType,
795
- * VpcId = aws_vpc.Example.Id,
987
+ * VpcEndpointType = example.ServiceType,
988
+ * VpcId = exampleAwsVpc.Id,
796
989
  * });
797
990
  *
798
991
  * });
@@ -808,29 +1001,29 @@ export declare namespace ec2 {
808
1001
  *
809
1002
  * func main() {
810
1003
  * pulumi.Run(func(ctx *pulumi.Context) error {
811
- * current, err := aws.GetCallerIdentity(ctx, nil, nil)
1004
+ * current, err := aws.GetCallerIdentity(ctx, &aws.GetCallerIdentityArgs{}, nil)
812
1005
  * if err != nil {
813
1006
  * return err
814
1007
  * }
815
- * exampleVpcEndpointService, err := ec2.NewVpcEndpointService(ctx, "exampleVpcEndpointService", &ec2.VpcEndpointServiceArgs{
1008
+ * example, err := ec2.NewVpcEndpointService(ctx, "example", &ec2.VpcEndpointServiceArgs{
816
1009
  * AcceptanceRequired: pulumi.Bool(false),
817
1010
  * AllowedPrincipals: pulumi.StringArray{
818
- * *pulumi.String(current.Arn),
1011
+ * pulumi.String(current.Arn),
819
1012
  * },
820
1013
  * GatewayLoadBalancerArns: pulumi.StringArray{
821
- * aws_lb.Example.Arn,
1014
+ * exampleAwsLb.Arn,
822
1015
  * },
823
1016
  * })
824
1017
  * if err != nil {
825
1018
  * return err
826
1019
  * }
827
- * _, err = ec2.NewVpcEndpoint(ctx, "exampleVpcEndpoint", &ec2.VpcEndpointArgs{
828
- * ServiceName: exampleVpcEndpointService.ServiceName,
1020
+ * _, err = ec2.NewVpcEndpoint(ctx, "example", &ec2.VpcEndpointArgs{
1021
+ * ServiceName: example.ServiceName,
829
1022
  * SubnetIds: pulumi.StringArray{
830
- * aws_subnet.Example.Id,
1023
+ * exampleAwsSubnet.Id,
831
1024
  * },
832
- * VpcEndpointType: exampleVpcEndpointService.ServiceType,
833
- * VpcId: pulumi.Any(aws_vpc.Example.Id),
1025
+ * VpcEndpointType: example.ServiceType,
1026
+ * VpcId: pulumi.Any(exampleAwsVpc.Id),
834
1027
  * })
835
1028
  * if err != nil {
836
1029
  * return err
@@ -866,17 +1059,17 @@ export declare namespace ec2 {
866
1059
  * public static void stack(Context ctx) {
867
1060
  * final var current = AwsFunctions.getCallerIdentity();
868
1061
  *
869
- * var exampleVpcEndpointService = new VpcEndpointService("exampleVpcEndpointService", VpcEndpointServiceArgs.builder()
1062
+ * var example = new VpcEndpointService("example", VpcEndpointServiceArgs.builder()
870
1063
  * .acceptanceRequired(false)
871
1064
  * .allowedPrincipals(current.applyValue(getCallerIdentityResult -> getCallerIdentityResult.arn()))
872
- * .gatewayLoadBalancerArns(aws_lb.example().arn())
1065
+ * .gatewayLoadBalancerArns(exampleAwsLb.arn())
873
1066
  * .build());
874
1067
  *
875
1068
  * var exampleVpcEndpoint = new VpcEndpoint("exampleVpcEndpoint", VpcEndpointArgs.builder()
876
- * .serviceName(exampleVpcEndpointService.serviceName())
877
- * .subnetIds(aws_subnet.example().id())
878
- * .vpcEndpointType(exampleVpcEndpointService.serviceType())
879
- * .vpcId(aws_vpc.example().id())
1069
+ * .serviceName(example.serviceName())
1070
+ * .subnetIds(exampleAwsSubnet.id())
1071
+ * .vpcEndpointType(example.serviceType())
1072
+ * .vpcId(exampleAwsVpc.id())
880
1073
  * .build());
881
1074
  *
882
1075
  * }
@@ -884,39 +1077,38 @@ export declare namespace ec2 {
884
1077
  * ```
885
1078
  * ```yaml
886
1079
  * resources:
887
- * exampleVpcEndpointService:
1080
+ * example:
888
1081
  * type: aws:ec2:VpcEndpointService
889
1082
  * properties:
890
1083
  * acceptanceRequired: false
891
1084
  * allowedPrincipals:
892
1085
  * - ${current.arn}
893
1086
  * gatewayLoadBalancerArns:
894
- * - ${aws_lb.example.arn}
1087
+ * - ${exampleAwsLb.arn}
895
1088
  * exampleVpcEndpoint:
896
1089
  * type: aws:ec2:VpcEndpoint
1090
+ * name: example
897
1091
  * properties:
898
- * serviceName: ${exampleVpcEndpointService.serviceName}
1092
+ * serviceName: ${example.serviceName}
899
1093
  * subnetIds:
900
- * - ${aws_subnet.example.id}
901
- * vpcEndpointType: ${exampleVpcEndpointService.serviceType}
902
- * vpcId: ${aws_vpc.example.id}
1094
+ * - ${exampleAwsSubnet.id}
1095
+ * vpcEndpointType: ${example.serviceType}
1096
+ * vpcId: ${exampleAwsVpc.id}
903
1097
  * variables:
904
1098
  * current:
905
1099
  * fn::invoke:
906
- * Function: aws:getCallerIdentity
907
- * Arguments: {}
1100
+ * function: aws:getCallerIdentity
1101
+ * arguments: {}
908
1102
  * ```
909
- * {{% /example %}}
910
- * {{% /examples %}}
1103
+ * <!--End PulumiCodeChooser -->
911
1104
  *
912
1105
  * ## Import
913
1106
  *
914
1107
  * Using `pulumi import`, import VPC Endpoints using the VPC endpoint `id`. For example:
915
1108
  *
916
1109
  * ```sh
917
- * $ pulumi import aws:ec2/vpcEndpoint:VpcEndpoint endpoint1 vpce-3ecf2a57
1110
+ * $ pulumi import aws:ec2/vpcEndpoint:VpcEndpoint endpoint1 vpce-3ecf2a57
918
1111
  * ```
919
- *
920
1112
  */
921
1113
  interface VpcEndpointSpecArgs {
922
1114
  /**
@@ -952,6 +1144,14 @@ export declare namespace ec2 {
952
1144
  * The service name. For AWS services the service name is usually in the form `com.amazonaws.<region>.<service>` (the SageMaker Notebook service is an exception to this rule, the service name is in the form `aws.sagemaker.<region>.notebook`).
953
1145
  */
954
1146
  serviceName: string;
1147
+ /**
1148
+ * The AWS region of the VPC Endpoint Service. If specified, the VPC endpoint will connect to the service in the provided region. Applicable for endpoints of type `Interface`.
1149
+ */
1150
+ serviceRegion?: pulumi.Input<string>;
1151
+ /**
1152
+ * Subnet configuration for the endpoint, used to select specific IPv4 and/or IPv6 addresses to the endpoint. See subnet_configuration below.
1153
+ */
1154
+ subnetConfigurations?: pulumi.Input<pulumi.Input<pulumiAws.types.input.ec2.VpcEndpointSubnetConfiguration>[]>;
955
1155
  /**
956
1156
  * The ID of one or more subnets in which to create a network interface for the endpoint. Applicable for endpoints of type `GatewayLoadBalancer` and `Interface`. Interface type endpoints cannot function without being assigned to a subnet.
957
1157
  */
@@ -1100,6 +1300,10 @@ export declare namespace ecs {
1100
1300
  * Will be created automatically if not defined.
1101
1301
  */
1102
1302
  taskRole?: inputs.awsx.DefaultRoleWithPolicyArgs;
1303
+ /**
1304
+ * Whether should track latest `ACTIVE` task definition on AWS or the one created with the resource stored in state. Default is `false`. Useful in the event the task definition is modified outside of this resource.
1305
+ */
1306
+ trackLatest?: pulumi.Input<boolean>;
1103
1307
  /**
1104
1308
  * Configuration block for volumes that containers in your task may use. Detailed below.
1105
1309
  */
@@ -1192,6 +1396,10 @@ export declare namespace ecs {
1192
1396
  * Will be created automatically if not defined.
1193
1397
  */
1194
1398
  taskRole?: inputs.awsx.DefaultRoleWithPolicyArgs;
1399
+ /**
1400
+ * Whether should track latest `ACTIVE` task definition on AWS or the one created with the resource stored in state. Default is `false`. Useful in the event the task definition is modified outside of this resource.
1401
+ */
1402
+ trackLatest?: pulumi.Input<boolean>;
1195
1403
  /**
1196
1404
  * Configuration block for volumes that containers in your task may use. Detailed below.
1197
1405
  */
@@ -1377,21 +1585,19 @@ export declare namespace lb {
1377
1585
  *
1378
1586
  * > **Note:** `aws.alb.Listener` is known as `aws.lb.Listener`. The functionality is identical.
1379
1587
  *
1380
- * {{% examples %}}
1381
1588
  * ## Example Usage
1382
- * {{% example %}}
1589
+ *
1383
1590
  * ### Forward Action
1384
1591
  *
1592
+ * <!--Start PulumiCodeChooser -->
1385
1593
  * ```typescript
1386
1594
  * import * as pulumi from "@pulumi/pulumi";
1387
1595
  * import * as aws from "@pulumi/aws";
1388
1596
  *
1389
- * const frontEndLoadBalancer = new aws.lb.LoadBalancer("frontEndLoadBalancer", {});
1390
- * // ...
1391
- * const frontEndTargetGroup = new aws.lb.TargetGroup("frontEndTargetGroup", {});
1392
- * // ...
1393
- * const frontEndListener = new aws.lb.Listener("frontEndListener", {
1394
- * loadBalancerArn: frontEndLoadBalancer.arn,
1597
+ * const frontEnd = new aws.lb.LoadBalancer("front_end", {});
1598
+ * const frontEndTargetGroup = new aws.lb.TargetGroup("front_end", {});
1599
+ * const frontEndListener = new aws.lb.Listener("front_end", {
1600
+ * loadBalancerArn: frontEnd.arn,
1395
1601
  * port: 443,
1396
1602
  * protocol: "HTTPS",
1397
1603
  * sslPolicy: "ELBSecurityPolicy-2016-08",
@@ -1406,20 +1612,18 @@ export declare namespace lb {
1406
1612
  * import pulumi
1407
1613
  * import pulumi_aws as aws
1408
1614
  *
1409
- * front_end_load_balancer = aws.lb.LoadBalancer("frontEndLoadBalancer")
1410
- * # ...
1411
- * front_end_target_group = aws.lb.TargetGroup("frontEndTargetGroup")
1412
- * # ...
1413
- * front_end_listener = aws.lb.Listener("frontEndListener",
1414
- * load_balancer_arn=front_end_load_balancer.arn,
1615
+ * front_end = aws.lb.LoadBalancer("front_end")
1616
+ * front_end_target_group = aws.lb.TargetGroup("front_end")
1617
+ * front_end_listener = aws.lb.Listener("front_end",
1618
+ * load_balancer_arn=front_end.arn,
1415
1619
  * port=443,
1416
1620
  * protocol="HTTPS",
1417
1621
  * ssl_policy="ELBSecurityPolicy-2016-08",
1418
1622
  * certificate_arn="arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4",
1419
- * default_actions=[aws.lb.ListenerDefaultActionArgs(
1420
- * type="forward",
1421
- * target_group_arn=front_end_target_group.arn,
1422
- * )])
1623
+ * default_actions=[{
1624
+ * "type": "forward",
1625
+ * "target_group_arn": front_end_target_group.arn,
1626
+ * }])
1423
1627
  * ```
1424
1628
  * ```csharp
1425
1629
  * using System.Collections.Generic;
@@ -1429,15 +1633,13 @@ export declare namespace lb {
1429
1633
  *
1430
1634
  * return await Deployment.RunAsync(() =>
1431
1635
  * {
1432
- * var frontEndLoadBalancer = new Aws.LB.LoadBalancer("frontEndLoadBalancer");
1636
+ * var frontEnd = new Aws.LB.LoadBalancer("front_end");
1433
1637
  *
1434
- * // ...
1435
- * var frontEndTargetGroup = new Aws.LB.TargetGroup("frontEndTargetGroup");
1638
+ * var frontEndTargetGroup = new Aws.LB.TargetGroup("front_end");
1436
1639
  *
1437
- * // ...
1438
- * var frontEndListener = new Aws.LB.Listener("frontEndListener", new()
1640
+ * var frontEndListener = new Aws.LB.Listener("front_end", new()
1439
1641
  * {
1440
- * LoadBalancerArn = frontEndLoadBalancer.Arn,
1642
+ * LoadBalancerArn = frontEnd.Arn,
1441
1643
  * Port = 443,
1442
1644
  * Protocol = "HTTPS",
1443
1645
  * SslPolicy = "ELBSecurityPolicy-2016-08",
@@ -1464,16 +1666,16 @@ export declare namespace lb {
1464
1666
  *
1465
1667
  * func main() {
1466
1668
  * pulumi.Run(func(ctx *pulumi.Context) error {
1467
- * frontEndLoadBalancer, err := lb.NewLoadBalancer(ctx, "frontEndLoadBalancer", nil)
1669
+ * frontEnd, err := lb.NewLoadBalancer(ctx, "front_end", nil)
1468
1670
  * if err != nil {
1469
1671
  * return err
1470
1672
  * }
1471
- * frontEndTargetGroup, err := lb.NewTargetGroup(ctx, "frontEndTargetGroup", nil)
1673
+ * frontEndTargetGroup, err := lb.NewTargetGroup(ctx, "front_end", nil)
1472
1674
  * if err != nil {
1473
1675
  * return err
1474
1676
  * }
1475
- * _, err = lb.NewListener(ctx, "frontEndListener", &lb.ListenerArgs{
1476
- * LoadBalancerArn: frontEndLoadBalancer.Arn,
1677
+ * _, err = lb.NewListener(ctx, "front_end", &lb.ListenerArgs{
1678
+ * LoadBalancerArn: frontEnd.Arn,
1477
1679
  * Port: pulumi.Int(443),
1478
1680
  * Protocol: pulumi.String("HTTPS"),
1479
1681
  * SslPolicy: pulumi.String("ELBSecurityPolicy-2016-08"),
@@ -1516,12 +1718,12 @@ export declare namespace lb {
1516
1718
  * }
1517
1719
  *
1518
1720
  * public static void stack(Context ctx) {
1519
- * var frontEndLoadBalancer = new LoadBalancer("frontEndLoadBalancer");
1721
+ * var frontEnd = new LoadBalancer("frontEnd");
1520
1722
  *
1521
1723
  * var frontEndTargetGroup = new TargetGroup("frontEndTargetGroup");
1522
1724
  *
1523
1725
  * var frontEndListener = new Listener("frontEndListener", ListenerArgs.builder()
1524
- * .loadBalancerArn(frontEndLoadBalancer.arn())
1726
+ * .loadBalancerArn(frontEnd.arn())
1525
1727
  * .port("443")
1526
1728
  * .protocol("HTTPS")
1527
1729
  * .sslPolicy("ELBSecurityPolicy-2016-08")
@@ -1537,14 +1739,17 @@ export declare namespace lb {
1537
1739
  * ```
1538
1740
  * ```yaml
1539
1741
  * resources:
1540
- * frontEndLoadBalancer:
1742
+ * frontEnd:
1541
1743
  * type: aws:lb:LoadBalancer
1744
+ * name: front_end
1542
1745
  * frontEndTargetGroup:
1543
1746
  * type: aws:lb:TargetGroup
1747
+ * name: front_end
1544
1748
  * frontEndListener:
1545
1749
  * type: aws:lb:Listener
1750
+ * name: front_end
1546
1751
  * properties:
1547
- * loadBalancerArn: ${frontEndLoadBalancer.arn}
1752
+ * loadBalancerArn: ${frontEnd.arn}
1548
1753
  * port: '443'
1549
1754
  * protocol: HTTPS
1550
1755
  * sslPolicy: ELBSecurityPolicy-2016-08
@@ -1553,22 +1758,25 @@ export declare namespace lb {
1553
1758
  * - type: forward
1554
1759
  * targetGroupArn: ${frontEndTargetGroup.arn}
1555
1760
  * ```
1761
+ * <!--End PulumiCodeChooser -->
1556
1762
  *
1557
1763
  * To a NLB:
1558
1764
  *
1765
+ * <!--Start PulumiCodeChooser -->
1559
1766
  * ```typescript
1560
1767
  * import * as pulumi from "@pulumi/pulumi";
1561
1768
  * import * as aws from "@pulumi/aws";
1562
1769
  *
1563
- * const frontEnd = new aws.lb.Listener("frontEnd", {
1564
- * loadBalancerArn: aws_lb.front_end.arn,
1770
+ * const frontEnd = new aws.lb.Listener("front_end", {
1771
+ * loadBalancerArn: frontEndAwsLb.arn,
1565
1772
  * port: 443,
1566
1773
  * protocol: "TLS",
1774
+ * sslPolicy: "ELBSecurityPolicy-2016-08",
1567
1775
  * certificateArn: "arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4",
1568
1776
  * alpnPolicy: "HTTP2Preferred",
1569
1777
  * defaultActions: [{
1570
1778
  * type: "forward",
1571
- * targetGroupArn: aws_lb_target_group.front_end.arn,
1779
+ * targetGroupArn: frontEndAwsLbTargetGroup.arn,
1572
1780
  * }],
1573
1781
  * });
1574
1782
  * ```
@@ -1576,16 +1784,17 @@ export declare namespace lb {
1576
1784
  * import pulumi
1577
1785
  * import pulumi_aws as aws
1578
1786
  *
1579
- * front_end = aws.lb.Listener("frontEnd",
1580
- * load_balancer_arn=aws_lb["front_end"]["arn"],
1787
+ * front_end = aws.lb.Listener("front_end",
1788
+ * load_balancer_arn=front_end_aws_lb["arn"],
1581
1789
  * port=443,
1582
1790
  * protocol="TLS",
1791
+ * ssl_policy="ELBSecurityPolicy-2016-08",
1583
1792
  * certificate_arn="arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4",
1584
1793
  * alpn_policy="HTTP2Preferred",
1585
- * default_actions=[aws.lb.ListenerDefaultActionArgs(
1586
- * type="forward",
1587
- * target_group_arn=aws_lb_target_group["front_end"]["arn"],
1588
- * )])
1794
+ * default_actions=[{
1795
+ * "type": "forward",
1796
+ * "target_group_arn": front_end_aws_lb_target_group["arn"],
1797
+ * }])
1589
1798
  * ```
1590
1799
  * ```csharp
1591
1800
  * using System.Collections.Generic;
@@ -1595,11 +1804,12 @@ export declare namespace lb {
1595
1804
  *
1596
1805
  * return await Deployment.RunAsync(() =>
1597
1806
  * {
1598
- * var frontEnd = new Aws.LB.Listener("frontEnd", new()
1807
+ * var frontEnd = new Aws.LB.Listener("front_end", new()
1599
1808
  * {
1600
- * LoadBalancerArn = aws_lb.Front_end.Arn,
1809
+ * LoadBalancerArn = frontEndAwsLb.Arn,
1601
1810
  * Port = 443,
1602
1811
  * Protocol = "TLS",
1812
+ * SslPolicy = "ELBSecurityPolicy-2016-08",
1603
1813
  * CertificateArn = "arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4",
1604
1814
  * AlpnPolicy = "HTTP2Preferred",
1605
1815
  * DefaultActions = new[]
@@ -1607,7 +1817,7 @@ export declare namespace lb {
1607
1817
  * new Aws.LB.Inputs.ListenerDefaultActionArgs
1608
1818
  * {
1609
1819
  * Type = "forward",
1610
- * TargetGroupArn = aws_lb_target_group.Front_end.Arn,
1820
+ * TargetGroupArn = frontEndAwsLbTargetGroup.Arn,
1611
1821
  * },
1612
1822
  * },
1613
1823
  * });
@@ -1624,16 +1834,17 @@ export declare namespace lb {
1624
1834
  *
1625
1835
  * func main() {
1626
1836
  * pulumi.Run(func(ctx *pulumi.Context) error {
1627
- * _, err := lb.NewListener(ctx, "frontEnd", &lb.ListenerArgs{
1628
- * LoadBalancerArn: pulumi.Any(aws_lb.Front_end.Arn),
1837
+ * _, err := lb.NewListener(ctx, "front_end", &lb.ListenerArgs{
1838
+ * LoadBalancerArn: pulumi.Any(frontEndAwsLb.Arn),
1629
1839
  * Port: pulumi.Int(443),
1630
1840
  * Protocol: pulumi.String("TLS"),
1841
+ * SslPolicy: pulumi.String("ELBSecurityPolicy-2016-08"),
1631
1842
  * CertificateArn: pulumi.String("arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4"),
1632
1843
  * AlpnPolicy: pulumi.String("HTTP2Preferred"),
1633
1844
  * DefaultActions: lb.ListenerDefaultActionArray{
1634
1845
  * &lb.ListenerDefaultActionArgs{
1635
1846
  * Type: pulumi.String("forward"),
1636
- * TargetGroupArn: pulumi.Any(aws_lb_target_group.Front_end.Arn),
1847
+ * TargetGroupArn: pulumi.Any(frontEndAwsLbTargetGroup.Arn),
1637
1848
  * },
1638
1849
  * },
1639
1850
  * })
@@ -1667,14 +1878,15 @@ export declare namespace lb {
1667
1878
  *
1668
1879
  * public static void stack(Context ctx) {
1669
1880
  * var frontEnd = new Listener("frontEnd", ListenerArgs.builder()
1670
- * .loadBalancerArn(aws_lb.front_end().arn())
1881
+ * .loadBalancerArn(frontEndAwsLb.arn())
1671
1882
  * .port("443")
1672
1883
  * .protocol("TLS")
1884
+ * .sslPolicy("ELBSecurityPolicy-2016-08")
1673
1885
  * .certificateArn("arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4")
1674
1886
  * .alpnPolicy("HTTP2Preferred")
1675
1887
  * .defaultActions(ListenerDefaultActionArgs.builder()
1676
1888
  * .type("forward")
1677
- * .targetGroupArn(aws_lb_target_group.front_end().arn())
1889
+ * .targetGroupArn(frontEndAwsLbTargetGroup.arn())
1678
1890
  * .build())
1679
1891
  * .build());
1680
1892
  *
@@ -1685,28 +1897,30 @@ export declare namespace lb {
1685
1897
  * resources:
1686
1898
  * frontEnd:
1687
1899
  * type: aws:lb:Listener
1900
+ * name: front_end
1688
1901
  * properties:
1689
- * loadBalancerArn: ${aws_lb.front_end.arn}
1902
+ * loadBalancerArn: ${frontEndAwsLb.arn}
1690
1903
  * port: '443'
1691
1904
  * protocol: TLS
1905
+ * sslPolicy: ELBSecurityPolicy-2016-08
1692
1906
  * certificateArn: arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4
1693
1907
  * alpnPolicy: HTTP2Preferred
1694
1908
  * defaultActions:
1695
1909
  * - type: forward
1696
- * targetGroupArn: ${aws_lb_target_group.front_end.arn}
1910
+ * targetGroupArn: ${frontEndAwsLbTargetGroup.arn}
1697
1911
  * ```
1698
- * {{% /example %}}
1699
- * {{% example %}}
1912
+ * <!--End PulumiCodeChooser -->
1913
+ *
1700
1914
  * ### Redirect Action
1701
1915
  *
1916
+ * <!--Start PulumiCodeChooser -->
1702
1917
  * ```typescript
1703
1918
  * import * as pulumi from "@pulumi/pulumi";
1704
1919
  * import * as aws from "@pulumi/aws";
1705
1920
  *
1706
- * const frontEndLoadBalancer = new aws.lb.LoadBalancer("frontEndLoadBalancer", {});
1707
- * // ...
1708
- * const frontEndListener = new aws.lb.Listener("frontEndListener", {
1709
- * loadBalancerArn: frontEndLoadBalancer.arn,
1921
+ * const frontEnd = new aws.lb.LoadBalancer("front_end", {});
1922
+ * const frontEndListener = new aws.lb.Listener("front_end", {
1923
+ * loadBalancerArn: frontEnd.arn,
1710
1924
  * port: 80,
1711
1925
  * protocol: "HTTP",
1712
1926
  * defaultActions: [{
@@ -1723,20 +1937,19 @@ export declare namespace lb {
1723
1937
  * import pulumi
1724
1938
  * import pulumi_aws as aws
1725
1939
  *
1726
- * front_end_load_balancer = aws.lb.LoadBalancer("frontEndLoadBalancer")
1727
- * # ...
1728
- * front_end_listener = aws.lb.Listener("frontEndListener",
1729
- * load_balancer_arn=front_end_load_balancer.arn,
1940
+ * front_end = aws.lb.LoadBalancer("front_end")
1941
+ * front_end_listener = aws.lb.Listener("front_end",
1942
+ * load_balancer_arn=front_end.arn,
1730
1943
  * port=80,
1731
1944
  * protocol="HTTP",
1732
- * default_actions=[aws.lb.ListenerDefaultActionArgs(
1733
- * type="redirect",
1734
- * redirect=aws.lb.ListenerDefaultActionRedirectArgs(
1735
- * port="443",
1736
- * protocol="HTTPS",
1737
- * status_code="HTTP_301",
1738
- * ),
1739
- * )])
1945
+ * default_actions=[{
1946
+ * "type": "redirect",
1947
+ * "redirect": {
1948
+ * "port": "443",
1949
+ * "protocol": "HTTPS",
1950
+ * "status_code": "HTTP_301",
1951
+ * },
1952
+ * }])
1740
1953
  * ```
1741
1954
  * ```csharp
1742
1955
  * using System.Collections.Generic;
@@ -1746,12 +1959,11 @@ export declare namespace lb {
1746
1959
  *
1747
1960
  * return await Deployment.RunAsync(() =>
1748
1961
  * {
1749
- * var frontEndLoadBalancer = new Aws.LB.LoadBalancer("frontEndLoadBalancer");
1962
+ * var frontEnd = new Aws.LB.LoadBalancer("front_end");
1750
1963
  *
1751
- * // ...
1752
- * var frontEndListener = new Aws.LB.Listener("frontEndListener", new()
1964
+ * var frontEndListener = new Aws.LB.Listener("front_end", new()
1753
1965
  * {
1754
- * LoadBalancerArn = frontEndLoadBalancer.Arn,
1966
+ * LoadBalancerArn = frontEnd.Arn,
1755
1967
  * Port = 80,
1756
1968
  * Protocol = "HTTP",
1757
1969
  * DefaultActions = new[]
@@ -1781,12 +1993,12 @@ export declare namespace lb {
1781
1993
  *
1782
1994
  * func main() {
1783
1995
  * pulumi.Run(func(ctx *pulumi.Context) error {
1784
- * frontEndLoadBalancer, err := lb.NewLoadBalancer(ctx, "frontEndLoadBalancer", nil)
1996
+ * frontEnd, err := lb.NewLoadBalancer(ctx, "front_end", nil)
1785
1997
  * if err != nil {
1786
1998
  * return err
1787
1999
  * }
1788
- * _, err = lb.NewListener(ctx, "frontEndListener", &lb.ListenerArgs{
1789
- * LoadBalancerArn: frontEndLoadBalancer.Arn,
2000
+ * _, err = lb.NewListener(ctx, "front_end", &lb.ListenerArgs{
2001
+ * LoadBalancerArn: frontEnd.Arn,
1790
2002
  * Port: pulumi.Int(80),
1791
2003
  * Protocol: pulumi.String("HTTP"),
1792
2004
  * DefaultActions: lb.ListenerDefaultActionArray{
@@ -1831,10 +2043,10 @@ export declare namespace lb {
1831
2043
  * }
1832
2044
  *
1833
2045
  * public static void stack(Context ctx) {
1834
- * var frontEndLoadBalancer = new LoadBalancer("frontEndLoadBalancer");
2046
+ * var frontEnd = new LoadBalancer("frontEnd");
1835
2047
  *
1836
2048
  * var frontEndListener = new Listener("frontEndListener", ListenerArgs.builder()
1837
- * .loadBalancerArn(frontEndLoadBalancer.arn())
2049
+ * .loadBalancerArn(frontEnd.arn())
1838
2050
  * .port("80")
1839
2051
  * .protocol("HTTP")
1840
2052
  * .defaultActions(ListenerDefaultActionArgs.builder()
@@ -1852,12 +2064,14 @@ export declare namespace lb {
1852
2064
  * ```
1853
2065
  * ```yaml
1854
2066
  * resources:
1855
- * frontEndLoadBalancer:
2067
+ * frontEnd:
1856
2068
  * type: aws:lb:LoadBalancer
2069
+ * name: front_end
1857
2070
  * frontEndListener:
1858
2071
  * type: aws:lb:Listener
2072
+ * name: front_end
1859
2073
  * properties:
1860
- * loadBalancerArn: ${frontEndLoadBalancer.arn}
2074
+ * loadBalancerArn: ${frontEnd.arn}
1861
2075
  * port: '80'
1862
2076
  * protocol: HTTP
1863
2077
  * defaultActions:
@@ -1867,18 +2081,18 @@ export declare namespace lb {
1867
2081
  * protocol: HTTPS
1868
2082
  * statusCode: HTTP_301
1869
2083
  * ```
1870
- * {{% /example %}}
1871
- * {{% example %}}
2084
+ * <!--End PulumiCodeChooser -->
2085
+ *
1872
2086
  * ### Fixed-response Action
1873
2087
  *
2088
+ * <!--Start PulumiCodeChooser -->
1874
2089
  * ```typescript
1875
2090
  * import * as pulumi from "@pulumi/pulumi";
1876
2091
  * import * as aws from "@pulumi/aws";
1877
2092
  *
1878
- * const frontEndLoadBalancer = new aws.lb.LoadBalancer("frontEndLoadBalancer", {});
1879
- * // ...
1880
- * const frontEndListener = new aws.lb.Listener("frontEndListener", {
1881
- * loadBalancerArn: frontEndLoadBalancer.arn,
2093
+ * const frontEnd = new aws.lb.LoadBalancer("front_end", {});
2094
+ * const frontEndListener = new aws.lb.Listener("front_end", {
2095
+ * loadBalancerArn: frontEnd.arn,
1882
2096
  * port: 80,
1883
2097
  * protocol: "HTTP",
1884
2098
  * defaultActions: [{
@@ -1895,20 +2109,19 @@ export declare namespace lb {
1895
2109
  * import pulumi
1896
2110
  * import pulumi_aws as aws
1897
2111
  *
1898
- * front_end_load_balancer = aws.lb.LoadBalancer("frontEndLoadBalancer")
1899
- * # ...
1900
- * front_end_listener = aws.lb.Listener("frontEndListener",
1901
- * load_balancer_arn=front_end_load_balancer.arn,
2112
+ * front_end = aws.lb.LoadBalancer("front_end")
2113
+ * front_end_listener = aws.lb.Listener("front_end",
2114
+ * load_balancer_arn=front_end.arn,
1902
2115
  * port=80,
1903
2116
  * protocol="HTTP",
1904
- * default_actions=[aws.lb.ListenerDefaultActionArgs(
1905
- * type="fixed-response",
1906
- * fixed_response=aws.lb.ListenerDefaultActionFixedResponseArgs(
1907
- * content_type="text/plain",
1908
- * message_body="Fixed response content",
1909
- * status_code="200",
1910
- * ),
1911
- * )])
2117
+ * default_actions=[{
2118
+ * "type": "fixed-response",
2119
+ * "fixed_response": {
2120
+ * "content_type": "text/plain",
2121
+ * "message_body": "Fixed response content",
2122
+ * "status_code": "200",
2123
+ * },
2124
+ * }])
1912
2125
  * ```
1913
2126
  * ```csharp
1914
2127
  * using System.Collections.Generic;
@@ -1918,12 +2131,11 @@ export declare namespace lb {
1918
2131
  *
1919
2132
  * return await Deployment.RunAsync(() =>
1920
2133
  * {
1921
- * var frontEndLoadBalancer = new Aws.LB.LoadBalancer("frontEndLoadBalancer");
2134
+ * var frontEnd = new Aws.LB.LoadBalancer("front_end");
1922
2135
  *
1923
- * // ...
1924
- * var frontEndListener = new Aws.LB.Listener("frontEndListener", new()
2136
+ * var frontEndListener = new Aws.LB.Listener("front_end", new()
1925
2137
  * {
1926
- * LoadBalancerArn = frontEndLoadBalancer.Arn,
2138
+ * LoadBalancerArn = frontEnd.Arn,
1927
2139
  * Port = 80,
1928
2140
  * Protocol = "HTTP",
1929
2141
  * DefaultActions = new[]
@@ -1953,12 +2165,12 @@ export declare namespace lb {
1953
2165
  *
1954
2166
  * func main() {
1955
2167
  * pulumi.Run(func(ctx *pulumi.Context) error {
1956
- * frontEndLoadBalancer, err := lb.NewLoadBalancer(ctx, "frontEndLoadBalancer", nil)
2168
+ * frontEnd, err := lb.NewLoadBalancer(ctx, "front_end", nil)
1957
2169
  * if err != nil {
1958
2170
  * return err
1959
2171
  * }
1960
- * _, err = lb.NewListener(ctx, "frontEndListener", &lb.ListenerArgs{
1961
- * LoadBalancerArn: frontEndLoadBalancer.Arn,
2172
+ * _, err = lb.NewListener(ctx, "front_end", &lb.ListenerArgs{
2173
+ * LoadBalancerArn: frontEnd.Arn,
1962
2174
  * Port: pulumi.Int(80),
1963
2175
  * Protocol: pulumi.String("HTTP"),
1964
2176
  * DefaultActions: lb.ListenerDefaultActionArray{
@@ -2003,10 +2215,10 @@ export declare namespace lb {
2003
2215
  * }
2004
2216
  *
2005
2217
  * public static void stack(Context ctx) {
2006
- * var frontEndLoadBalancer = new LoadBalancer("frontEndLoadBalancer");
2218
+ * var frontEnd = new LoadBalancer("frontEnd");
2007
2219
  *
2008
2220
  * var frontEndListener = new Listener("frontEndListener", ListenerArgs.builder()
2009
- * .loadBalancerArn(frontEndLoadBalancer.arn())
2221
+ * .loadBalancerArn(frontEnd.arn())
2010
2222
  * .port("80")
2011
2223
  * .protocol("HTTP")
2012
2224
  * .defaultActions(ListenerDefaultActionArgs.builder()
@@ -2024,12 +2236,14 @@ export declare namespace lb {
2024
2236
  * ```
2025
2237
  * ```yaml
2026
2238
  * resources:
2027
- * frontEndLoadBalancer:
2239
+ * frontEnd:
2028
2240
  * type: aws:lb:LoadBalancer
2241
+ * name: front_end
2029
2242
  * frontEndListener:
2030
2243
  * type: aws:lb:Listener
2244
+ * name: front_end
2031
2245
  * properties:
2032
- * loadBalancerArn: ${frontEndLoadBalancer.arn}
2246
+ * loadBalancerArn: ${frontEnd.arn}
2033
2247
  * port: '80'
2034
2248
  * protocol: HTTP
2035
2249
  * defaultActions:
@@ -2039,26 +2253,22 @@ export declare namespace lb {
2039
2253
  * messageBody: Fixed response content
2040
2254
  * statusCode: '200'
2041
2255
  * ```
2042
- * {{% /example %}}
2043
- * {{% example %}}
2256
+ * <!--End PulumiCodeChooser -->
2257
+ *
2044
2258
  * ### Authenticate-cognito Action
2045
2259
  *
2260
+ * <!--Start PulumiCodeChooser -->
2046
2261
  * ```typescript
2047
2262
  * import * as pulumi from "@pulumi/pulumi";
2048
2263
  * import * as aws from "@pulumi/aws";
2049
2264
  *
2050
- * const frontEndLoadBalancer = new aws.lb.LoadBalancer("frontEndLoadBalancer", {});
2051
- * // ...
2052
- * const frontEndTargetGroup = new aws.lb.TargetGroup("frontEndTargetGroup", {});
2053
- * // ...
2265
+ * const frontEnd = new aws.lb.LoadBalancer("front_end", {});
2266
+ * const frontEndTargetGroup = new aws.lb.TargetGroup("front_end", {});
2054
2267
  * const pool = new aws.cognito.UserPool("pool", {});
2055
- * // ...
2056
2268
  * const client = new aws.cognito.UserPoolClient("client", {});
2057
- * // ...
2058
2269
  * const domain = new aws.cognito.UserPoolDomain("domain", {});
2059
- * // ...
2060
- * const frontEndListener = new aws.lb.Listener("frontEndListener", {
2061
- * loadBalancerArn: frontEndLoadBalancer.arn,
2270
+ * const frontEndListener = new aws.lb.Listener("front_end", {
2271
+ * loadBalancerArn: frontEnd.arn,
2062
2272
  * port: 80,
2063
2273
  * protocol: "HTTP",
2064
2274
  * defaultActions: [
@@ -2081,33 +2291,28 @@ export declare namespace lb {
2081
2291
  * import pulumi
2082
2292
  * import pulumi_aws as aws
2083
2293
  *
2084
- * front_end_load_balancer = aws.lb.LoadBalancer("frontEndLoadBalancer")
2085
- * # ...
2086
- * front_end_target_group = aws.lb.TargetGroup("frontEndTargetGroup")
2087
- * # ...
2294
+ * front_end = aws.lb.LoadBalancer("front_end")
2295
+ * front_end_target_group = aws.lb.TargetGroup("front_end")
2088
2296
  * pool = aws.cognito.UserPool("pool")
2089
- * # ...
2090
2297
  * client = aws.cognito.UserPoolClient("client")
2091
- * # ...
2092
2298
  * domain = aws.cognito.UserPoolDomain("domain")
2093
- * # ...
2094
- * front_end_listener = aws.lb.Listener("frontEndListener",
2095
- * load_balancer_arn=front_end_load_balancer.arn,
2299
+ * front_end_listener = aws.lb.Listener("front_end",
2300
+ * load_balancer_arn=front_end.arn,
2096
2301
  * port=80,
2097
2302
  * protocol="HTTP",
2098
2303
  * default_actions=[
2099
- * aws.lb.ListenerDefaultActionArgs(
2100
- * type="authenticate-cognito",
2101
- * authenticate_cognito=aws.lb.ListenerDefaultActionAuthenticateCognitoArgs(
2102
- * user_pool_arn=pool.arn,
2103
- * user_pool_client_id=client.id,
2104
- * user_pool_domain=domain.domain,
2105
- * ),
2106
- * ),
2107
- * aws.lb.ListenerDefaultActionArgs(
2108
- * type="forward",
2109
- * target_group_arn=front_end_target_group.arn,
2110
- * ),
2304
+ * {
2305
+ * "type": "authenticate-cognito",
2306
+ * "authenticate_cognito": {
2307
+ * "user_pool_arn": pool.arn,
2308
+ * "user_pool_client_id": client.id,
2309
+ * "user_pool_domain": domain.domain,
2310
+ * },
2311
+ * },
2312
+ * {
2313
+ * "type": "forward",
2314
+ * "target_group_arn": front_end_target_group.arn,
2315
+ * },
2111
2316
  * ])
2112
2317
  * ```
2113
2318
  * ```csharp
@@ -2118,24 +2323,19 @@ export declare namespace lb {
2118
2323
  *
2119
2324
  * return await Deployment.RunAsync(() =>
2120
2325
  * {
2121
- * var frontEndLoadBalancer = new Aws.LB.LoadBalancer("frontEndLoadBalancer");
2326
+ * var frontEnd = new Aws.LB.LoadBalancer("front_end");
2122
2327
  *
2123
- * // ...
2124
- * var frontEndTargetGroup = new Aws.LB.TargetGroup("frontEndTargetGroup");
2328
+ * var frontEndTargetGroup = new Aws.LB.TargetGroup("front_end");
2125
2329
  *
2126
- * // ...
2127
2330
  * var pool = new Aws.Cognito.UserPool("pool");
2128
2331
  *
2129
- * // ...
2130
2332
  * var client = new Aws.Cognito.UserPoolClient("client");
2131
2333
  *
2132
- * // ...
2133
2334
  * var domain = new Aws.Cognito.UserPoolDomain("domain");
2134
2335
  *
2135
- * // ...
2136
- * var frontEndListener = new Aws.LB.Listener("frontEndListener", new()
2336
+ * var frontEndListener = new Aws.LB.Listener("front_end", new()
2137
2337
  * {
2138
- * LoadBalancerArn = frontEndLoadBalancer.Arn,
2338
+ * LoadBalancerArn = frontEnd.Arn,
2139
2339
  * Port = 80,
2140
2340
  * Protocol = "HTTP",
2141
2341
  * DefaultActions = new[]
@@ -2171,11 +2371,11 @@ export declare namespace lb {
2171
2371
  *
2172
2372
  * func main() {
2173
2373
  * pulumi.Run(func(ctx *pulumi.Context) error {
2174
- * frontEndLoadBalancer, err := lb.NewLoadBalancer(ctx, "frontEndLoadBalancer", nil)
2374
+ * frontEnd, err := lb.NewLoadBalancer(ctx, "front_end", nil)
2175
2375
  * if err != nil {
2176
2376
  * return err
2177
2377
  * }
2178
- * frontEndTargetGroup, err := lb.NewTargetGroup(ctx, "frontEndTargetGroup", nil)
2378
+ * frontEndTargetGroup, err := lb.NewTargetGroup(ctx, "front_end", nil)
2179
2379
  * if err != nil {
2180
2380
  * return err
2181
2381
  * }
@@ -2191,8 +2391,8 @@ export declare namespace lb {
2191
2391
  * if err != nil {
2192
2392
  * return err
2193
2393
  * }
2194
- * _, err = lb.NewListener(ctx, "frontEndListener", &lb.ListenerArgs{
2195
- * LoadBalancerArn: frontEndLoadBalancer.Arn,
2394
+ * _, err = lb.NewListener(ctx, "front_end", &lb.ListenerArgs{
2395
+ * LoadBalancerArn: frontEnd.Arn,
2196
2396
  * Port: pulumi.Int(80),
2197
2397
  * Protocol: pulumi.String("HTTP"),
2198
2398
  * DefaultActions: lb.ListenerDefaultActionArray{
@@ -2245,7 +2445,7 @@ export declare namespace lb {
2245
2445
  * }
2246
2446
  *
2247
2447
  * public static void stack(Context ctx) {
2248
- * var frontEndLoadBalancer = new LoadBalancer("frontEndLoadBalancer");
2448
+ * var frontEnd = new LoadBalancer("frontEnd");
2249
2449
  *
2250
2450
  * var frontEndTargetGroup = new TargetGroup("frontEndTargetGroup");
2251
2451
  *
@@ -2256,7 +2456,7 @@ export declare namespace lb {
2256
2456
  * var domain = new UserPoolDomain("domain");
2257
2457
  *
2258
2458
  * var frontEndListener = new Listener("frontEndListener", ListenerArgs.builder()
2259
- * .loadBalancerArn(frontEndLoadBalancer.arn())
2459
+ * .loadBalancerArn(frontEnd.arn())
2260
2460
  * .port("80")
2261
2461
  * .protocol("HTTP")
2262
2462
  * .defaultActions(
@@ -2279,10 +2479,12 @@ export declare namespace lb {
2279
2479
  * ```
2280
2480
  * ```yaml
2281
2481
  * resources:
2282
- * frontEndLoadBalancer:
2482
+ * frontEnd:
2283
2483
  * type: aws:lb:LoadBalancer
2484
+ * name: front_end
2284
2485
  * frontEndTargetGroup:
2285
2486
  * type: aws:lb:TargetGroup
2487
+ * name: front_end
2286
2488
  * pool:
2287
2489
  * type: aws:cognito:UserPool
2288
2490
  * client:
@@ -2291,8 +2493,9 @@ export declare namespace lb {
2291
2493
  * type: aws:cognito:UserPoolDomain
2292
2494
  * frontEndListener:
2293
2495
  * type: aws:lb:Listener
2496
+ * name: front_end
2294
2497
  * properties:
2295
- * loadBalancerArn: ${frontEndLoadBalancer.arn}
2498
+ * loadBalancerArn: ${frontEnd.arn}
2296
2499
  * port: '80'
2297
2500
  * protocol: HTTP
2298
2501
  * defaultActions:
@@ -2304,20 +2507,19 @@ export declare namespace lb {
2304
2507
  * - type: forward
2305
2508
  * targetGroupArn: ${frontEndTargetGroup.arn}
2306
2509
  * ```
2307
- * {{% /example %}}
2308
- * {{% example %}}
2510
+ * <!--End PulumiCodeChooser -->
2511
+ *
2309
2512
  * ### Authenticate-OIDC Action
2310
2513
  *
2514
+ * <!--Start PulumiCodeChooser -->
2311
2515
  * ```typescript
2312
2516
  * import * as pulumi from "@pulumi/pulumi";
2313
2517
  * import * as aws from "@pulumi/aws";
2314
2518
  *
2315
- * const frontEndLoadBalancer = new aws.lb.LoadBalancer("frontEndLoadBalancer", {});
2316
- * // ...
2317
- * const frontEndTargetGroup = new aws.lb.TargetGroup("frontEndTargetGroup", {});
2318
- * // ...
2319
- * const frontEndListener = new aws.lb.Listener("frontEndListener", {
2320
- * loadBalancerArn: frontEndLoadBalancer.arn,
2519
+ * const frontEnd = new aws.lb.LoadBalancer("front_end", {});
2520
+ * const frontEndTargetGroup = new aws.lb.TargetGroup("front_end", {});
2521
+ * const frontEndListener = new aws.lb.Listener("front_end", {
2522
+ * loadBalancerArn: frontEnd.arn,
2321
2523
  * port: 80,
2322
2524
  * protocol: "HTTP",
2323
2525
  * defaultActions: [
@@ -2343,30 +2545,28 @@ export declare namespace lb {
2343
2545
  * import pulumi
2344
2546
  * import pulumi_aws as aws
2345
2547
  *
2346
- * front_end_load_balancer = aws.lb.LoadBalancer("frontEndLoadBalancer")
2347
- * # ...
2348
- * front_end_target_group = aws.lb.TargetGroup("frontEndTargetGroup")
2349
- * # ...
2350
- * front_end_listener = aws.lb.Listener("frontEndListener",
2351
- * load_balancer_arn=front_end_load_balancer.arn,
2548
+ * front_end = aws.lb.LoadBalancer("front_end")
2549
+ * front_end_target_group = aws.lb.TargetGroup("front_end")
2550
+ * front_end_listener = aws.lb.Listener("front_end",
2551
+ * load_balancer_arn=front_end.arn,
2352
2552
  * port=80,
2353
2553
  * protocol="HTTP",
2354
2554
  * default_actions=[
2355
- * aws.lb.ListenerDefaultActionArgs(
2356
- * type="authenticate-oidc",
2357
- * authenticate_oidc=aws.lb.ListenerDefaultActionAuthenticateOidcArgs(
2358
- * authorization_endpoint="https://example.com/authorization_endpoint",
2359
- * client_id="client_id",
2360
- * client_secret="client_secret",
2361
- * issuer="https://example.com",
2362
- * token_endpoint="https://example.com/token_endpoint",
2363
- * user_info_endpoint="https://example.com/user_info_endpoint",
2364
- * ),
2365
- * ),
2366
- * aws.lb.ListenerDefaultActionArgs(
2367
- * type="forward",
2368
- * target_group_arn=front_end_target_group.arn,
2369
- * ),
2555
+ * {
2556
+ * "type": "authenticate-oidc",
2557
+ * "authenticate_oidc": {
2558
+ * "authorization_endpoint": "https://example.com/authorization_endpoint",
2559
+ * "client_id": "client_id",
2560
+ * "client_secret": "client_secret",
2561
+ * "issuer": "https://example.com",
2562
+ * "token_endpoint": "https://example.com/token_endpoint",
2563
+ * "user_info_endpoint": "https://example.com/user_info_endpoint",
2564
+ * },
2565
+ * },
2566
+ * {
2567
+ * "type": "forward",
2568
+ * "target_group_arn": front_end_target_group.arn,
2569
+ * },
2370
2570
  * ])
2371
2571
  * ```
2372
2572
  * ```csharp
@@ -2377,15 +2577,13 @@ export declare namespace lb {
2377
2577
  *
2378
2578
  * return await Deployment.RunAsync(() =>
2379
2579
  * {
2380
- * var frontEndLoadBalancer = new Aws.LB.LoadBalancer("frontEndLoadBalancer");
2580
+ * var frontEnd = new Aws.LB.LoadBalancer("front_end");
2381
2581
  *
2382
- * // ...
2383
- * var frontEndTargetGroup = new Aws.LB.TargetGroup("frontEndTargetGroup");
2582
+ * var frontEndTargetGroup = new Aws.LB.TargetGroup("front_end");
2384
2583
  *
2385
- * // ...
2386
- * var frontEndListener = new Aws.LB.Listener("frontEndListener", new()
2584
+ * var frontEndListener = new Aws.LB.Listener("front_end", new()
2387
2585
  * {
2388
- * LoadBalancerArn = frontEndLoadBalancer.Arn,
2586
+ * LoadBalancerArn = frontEnd.Arn,
2389
2587
  * Port = 80,
2390
2588
  * Protocol = "HTTP",
2391
2589
  * DefaultActions = new[]
@@ -2423,16 +2621,16 @@ export declare namespace lb {
2423
2621
  *
2424
2622
  * func main() {
2425
2623
  * pulumi.Run(func(ctx *pulumi.Context) error {
2426
- * frontEndLoadBalancer, err := lb.NewLoadBalancer(ctx, "frontEndLoadBalancer", nil)
2624
+ * frontEnd, err := lb.NewLoadBalancer(ctx, "front_end", nil)
2427
2625
  * if err != nil {
2428
2626
  * return err
2429
2627
  * }
2430
- * frontEndTargetGroup, err := lb.NewTargetGroup(ctx, "frontEndTargetGroup", nil)
2628
+ * frontEndTargetGroup, err := lb.NewTargetGroup(ctx, "front_end", nil)
2431
2629
  * if err != nil {
2432
2630
  * return err
2433
2631
  * }
2434
- * _, err = lb.NewListener(ctx, "frontEndListener", &lb.ListenerArgs{
2435
- * LoadBalancerArn: frontEndLoadBalancer.Arn,
2632
+ * _, err = lb.NewListener(ctx, "front_end", &lb.ListenerArgs{
2633
+ * LoadBalancerArn: frontEnd.Arn,
2436
2634
  * Port: pulumi.Int(80),
2437
2635
  * Protocol: pulumi.String("HTTP"),
2438
2636
  * DefaultActions: lb.ListenerDefaultActionArray{
@@ -2485,12 +2683,12 @@ export declare namespace lb {
2485
2683
  * }
2486
2684
  *
2487
2685
  * public static void stack(Context ctx) {
2488
- * var frontEndLoadBalancer = new LoadBalancer("frontEndLoadBalancer");
2686
+ * var frontEnd = new LoadBalancer("frontEnd");
2489
2687
  *
2490
2688
  * var frontEndTargetGroup = new TargetGroup("frontEndTargetGroup");
2491
2689
  *
2492
2690
  * var frontEndListener = new Listener("frontEndListener", ListenerArgs.builder()
2493
- * .loadBalancerArn(frontEndLoadBalancer.arn())
2691
+ * .loadBalancerArn(frontEnd.arn())
2494
2692
  * .port("80")
2495
2693
  * .protocol("HTTP")
2496
2694
  * .defaultActions(
@@ -2516,14 +2714,17 @@ export declare namespace lb {
2516
2714
  * ```
2517
2715
  * ```yaml
2518
2716
  * resources:
2519
- * frontEndLoadBalancer:
2717
+ * frontEnd:
2520
2718
  * type: aws:lb:LoadBalancer
2719
+ * name: front_end
2521
2720
  * frontEndTargetGroup:
2522
2721
  * type: aws:lb:TargetGroup
2722
+ * name: front_end
2523
2723
  * frontEndListener:
2524
2724
  * type: aws:lb:Listener
2725
+ * name: front_end
2525
2726
  * properties:
2526
- * loadBalancerArn: ${frontEndLoadBalancer.arn}
2727
+ * loadBalancerArn: ${frontEnd.arn}
2527
2728
  * port: '80'
2528
2729
  * protocol: HTTP
2529
2730
  * defaultActions:
@@ -2538,31 +2739,34 @@ export declare namespace lb {
2538
2739
  * - type: forward
2539
2740
  * targetGroupArn: ${frontEndTargetGroup.arn}
2540
2741
  * ```
2541
- * {{% /example %}}
2542
- * {{% example %}}
2742
+ * <!--End PulumiCodeChooser -->
2743
+ *
2543
2744
  * ### Gateway Load Balancer Listener
2544
2745
  *
2746
+ * <!--Start PulumiCodeChooser -->
2545
2747
  * ```typescript
2546
2748
  * import * as pulumi from "@pulumi/pulumi";
2547
2749
  * import * as aws from "@pulumi/aws";
2548
2750
  *
2549
- * const exampleLoadBalancer = new aws.lb.LoadBalancer("exampleLoadBalancer", {
2751
+ * const example = new aws.lb.LoadBalancer("example", {
2550
2752
  * loadBalancerType: "gateway",
2753
+ * name: "example",
2551
2754
  * subnetMappings: [{
2552
- * subnetId: aws_subnet.example.id,
2755
+ * subnetId: exampleAwsSubnet.id,
2553
2756
  * }],
2554
2757
  * });
2555
- * const exampleTargetGroup = new aws.lb.TargetGroup("exampleTargetGroup", {
2758
+ * const exampleTargetGroup = new aws.lb.TargetGroup("example", {
2759
+ * name: "example",
2556
2760
  * port: 6081,
2557
2761
  * protocol: "GENEVE",
2558
- * vpcId: aws_vpc.example.id,
2762
+ * vpcId: exampleAwsVpc.id,
2559
2763
  * healthCheck: {
2560
2764
  * port: "80",
2561
2765
  * protocol: "HTTP",
2562
2766
  * },
2563
2767
  * });
2564
- * const exampleListener = new aws.lb.Listener("exampleListener", {
2565
- * loadBalancerArn: exampleLoadBalancer.id,
2768
+ * const exampleListener = new aws.lb.Listener("example", {
2769
+ * loadBalancerArn: example.id,
2566
2770
  * defaultActions: [{
2567
2771
  * targetGroupArn: exampleTargetGroup.id,
2568
2772
  * type: "forward",
@@ -2573,25 +2777,27 @@ export declare namespace lb {
2573
2777
  * import pulumi
2574
2778
  * import pulumi_aws as aws
2575
2779
  *
2576
- * example_load_balancer = aws.lb.LoadBalancer("exampleLoadBalancer",
2780
+ * example = aws.lb.LoadBalancer("example",
2577
2781
  * load_balancer_type="gateway",
2578
- * subnet_mappings=[aws.lb.LoadBalancerSubnetMappingArgs(
2579
- * subnet_id=aws_subnet["example"]["id"],
2580
- * )])
2581
- * example_target_group = aws.lb.TargetGroup("exampleTargetGroup",
2782
+ * name="example",
2783
+ * subnet_mappings=[{
2784
+ * "subnet_id": example_aws_subnet["id"],
2785
+ * }])
2786
+ * example_target_group = aws.lb.TargetGroup("example",
2787
+ * name="example",
2582
2788
  * port=6081,
2583
2789
  * protocol="GENEVE",
2584
- * vpc_id=aws_vpc["example"]["id"],
2585
- * health_check=aws.lb.TargetGroupHealthCheckArgs(
2586
- * port="80",
2587
- * protocol="HTTP",
2588
- * ))
2589
- * example_listener = aws.lb.Listener("exampleListener",
2590
- * load_balancer_arn=example_load_balancer.id,
2591
- * default_actions=[aws.lb.ListenerDefaultActionArgs(
2592
- * target_group_arn=example_target_group.id,
2593
- * type="forward",
2594
- * )])
2790
+ * vpc_id=example_aws_vpc["id"],
2791
+ * health_check={
2792
+ * "port": "80",
2793
+ * "protocol": "HTTP",
2794
+ * })
2795
+ * example_listener = aws.lb.Listener("example",
2796
+ * load_balancer_arn=example.id,
2797
+ * default_actions=[{
2798
+ * "target_group_arn": example_target_group.id,
2799
+ * "type": "forward",
2800
+ * }])
2595
2801
  * ```
2596
2802
  * ```csharp
2597
2803
  * using System.Collections.Generic;
@@ -2601,23 +2807,25 @@ export declare namespace lb {
2601
2807
  *
2602
2808
  * return await Deployment.RunAsync(() =>
2603
2809
  * {
2604
- * var exampleLoadBalancer = new Aws.LB.LoadBalancer("exampleLoadBalancer", new()
2810
+ * var example = new Aws.LB.LoadBalancer("example", new()
2605
2811
  * {
2606
2812
  * LoadBalancerType = "gateway",
2813
+ * Name = "example",
2607
2814
  * SubnetMappings = new[]
2608
2815
  * {
2609
2816
  * new Aws.LB.Inputs.LoadBalancerSubnetMappingArgs
2610
2817
  * {
2611
- * SubnetId = aws_subnet.Example.Id,
2818
+ * SubnetId = exampleAwsSubnet.Id,
2612
2819
  * },
2613
2820
  * },
2614
2821
  * });
2615
2822
  *
2616
- * var exampleTargetGroup = new Aws.LB.TargetGroup("exampleTargetGroup", new()
2823
+ * var exampleTargetGroup = new Aws.LB.TargetGroup("example", new()
2617
2824
  * {
2825
+ * Name = "example",
2618
2826
  * Port = 6081,
2619
2827
  * Protocol = "GENEVE",
2620
- * VpcId = aws_vpc.Example.Id,
2828
+ * VpcId = exampleAwsVpc.Id,
2621
2829
  * HealthCheck = new Aws.LB.Inputs.TargetGroupHealthCheckArgs
2622
2830
  * {
2623
2831
  * Port = "80",
@@ -2625,9 +2833,9 @@ export declare namespace lb {
2625
2833
  * },
2626
2834
  * });
2627
2835
  *
2628
- * var exampleListener = new Aws.LB.Listener("exampleListener", new()
2836
+ * var exampleListener = new Aws.LB.Listener("example", new()
2629
2837
  * {
2630
- * LoadBalancerArn = exampleLoadBalancer.Id,
2838
+ * LoadBalancerArn = example.Id,
2631
2839
  * DefaultActions = new[]
2632
2840
  * {
2633
2841
  * new Aws.LB.Inputs.ListenerDefaultActionArgs
@@ -2650,21 +2858,23 @@ export declare namespace lb {
2650
2858
  *
2651
2859
  * func main() {
2652
2860
  * pulumi.Run(func(ctx *pulumi.Context) error {
2653
- * exampleLoadBalancer, err := lb.NewLoadBalancer(ctx, "exampleLoadBalancer", &lb.LoadBalancerArgs{
2861
+ * example, err := lb.NewLoadBalancer(ctx, "example", &lb.LoadBalancerArgs{
2654
2862
  * LoadBalancerType: pulumi.String("gateway"),
2863
+ * Name: pulumi.String("example"),
2655
2864
  * SubnetMappings: lb.LoadBalancerSubnetMappingArray{
2656
2865
  * &lb.LoadBalancerSubnetMappingArgs{
2657
- * SubnetId: pulumi.Any(aws_subnet.Example.Id),
2866
+ * SubnetId: pulumi.Any(exampleAwsSubnet.Id),
2658
2867
  * },
2659
2868
  * },
2660
2869
  * })
2661
2870
  * if err != nil {
2662
2871
  * return err
2663
2872
  * }
2664
- * exampleTargetGroup, err := lb.NewTargetGroup(ctx, "exampleTargetGroup", &lb.TargetGroupArgs{
2873
+ * exampleTargetGroup, err := lb.NewTargetGroup(ctx, "example", &lb.TargetGroupArgs{
2874
+ * Name: pulumi.String("example"),
2665
2875
  * Port: pulumi.Int(6081),
2666
2876
  * Protocol: pulumi.String("GENEVE"),
2667
- * VpcId: pulumi.Any(aws_vpc.Example.Id),
2877
+ * VpcId: pulumi.Any(exampleAwsVpc.Id),
2668
2878
  * HealthCheck: &lb.TargetGroupHealthCheckArgs{
2669
2879
  * Port: pulumi.String("80"),
2670
2880
  * Protocol: pulumi.String("HTTP"),
@@ -2673,8 +2883,8 @@ export declare namespace lb {
2673
2883
  * if err != nil {
2674
2884
  * return err
2675
2885
  * }
2676
- * _, err = lb.NewListener(ctx, "exampleListener", &lb.ListenerArgs{
2677
- * LoadBalancerArn: exampleLoadBalancer.ID(),
2886
+ * _, err = lb.NewListener(ctx, "example", &lb.ListenerArgs{
2887
+ * LoadBalancerArn: example.ID(),
2678
2888
  * DefaultActions: lb.ListenerDefaultActionArray{
2679
2889
  * &lb.ListenerDefaultActionArgs{
2680
2890
  * TargetGroupArn: exampleTargetGroup.ID(),
@@ -2717,17 +2927,19 @@ export declare namespace lb {
2717
2927
  * }
2718
2928
  *
2719
2929
  * public static void stack(Context ctx) {
2720
- * var exampleLoadBalancer = new LoadBalancer("exampleLoadBalancer", LoadBalancerArgs.builder()
2930
+ * var example = new LoadBalancer("example", LoadBalancerArgs.builder()
2721
2931
  * .loadBalancerType("gateway")
2932
+ * .name("example")
2722
2933
  * .subnetMappings(LoadBalancerSubnetMappingArgs.builder()
2723
- * .subnetId(aws_subnet.example().id())
2934
+ * .subnetId(exampleAwsSubnet.id())
2724
2935
  * .build())
2725
2936
  * .build());
2726
2937
  *
2727
2938
  * var exampleTargetGroup = new TargetGroup("exampleTargetGroup", TargetGroupArgs.builder()
2939
+ * .name("example")
2728
2940
  * .port(6081)
2729
2941
  * .protocol("GENEVE")
2730
- * .vpcId(aws_vpc.example().id())
2942
+ * .vpcId(exampleAwsVpc.id())
2731
2943
  * .healthCheck(TargetGroupHealthCheckArgs.builder()
2732
2944
  * .port(80)
2733
2945
  * .protocol("HTTP")
@@ -2735,7 +2947,7 @@ export declare namespace lb {
2735
2947
  * .build());
2736
2948
  *
2737
2949
  * var exampleListener = new Listener("exampleListener", ListenerArgs.builder()
2738
- * .loadBalancerArn(exampleLoadBalancer.id())
2950
+ * .loadBalancerArn(example.id())
2739
2951
  * .defaultActions(ListenerDefaultActionArgs.builder()
2740
2952
  * .targetGroupArn(exampleTargetGroup.id())
2741
2953
  * .type("forward")
@@ -2747,40 +2959,225 @@ export declare namespace lb {
2747
2959
  * ```
2748
2960
  * ```yaml
2749
2961
  * resources:
2750
- * exampleLoadBalancer:
2962
+ * example:
2751
2963
  * type: aws:lb:LoadBalancer
2752
2964
  * properties:
2753
2965
  * loadBalancerType: gateway
2966
+ * name: example
2754
2967
  * subnetMappings:
2755
- * - subnetId: ${aws_subnet.example.id}
2968
+ * - subnetId: ${exampleAwsSubnet.id}
2756
2969
  * exampleTargetGroup:
2757
2970
  * type: aws:lb:TargetGroup
2971
+ * name: example
2758
2972
  * properties:
2973
+ * name: example
2759
2974
  * port: 6081
2760
2975
  * protocol: GENEVE
2761
- * vpcId: ${aws_vpc.example.id}
2976
+ * vpcId: ${exampleAwsVpc.id}
2762
2977
  * healthCheck:
2763
2978
  * port: 80
2764
2979
  * protocol: HTTP
2765
2980
  * exampleListener:
2766
2981
  * type: aws:lb:Listener
2982
+ * name: example
2767
2983
  * properties:
2768
- * loadBalancerArn: ${exampleLoadBalancer.id}
2984
+ * loadBalancerArn: ${example.id}
2769
2985
  * defaultActions:
2770
2986
  * - targetGroupArn: ${exampleTargetGroup.id}
2771
2987
  * type: forward
2772
2988
  * ```
2773
- * {{% /example %}}
2774
- * {{% /examples %}}
2989
+ * <!--End PulumiCodeChooser -->
2990
+ *
2991
+ * ### Mutual TLS Authentication
2992
+ *
2993
+ * <!--Start PulumiCodeChooser -->
2994
+ * ```typescript
2995
+ * import * as pulumi from "@pulumi/pulumi";
2996
+ * import * as aws from "@pulumi/aws";
2997
+ *
2998
+ * const example = new aws.lb.LoadBalancer("example", {loadBalancerType: "application"});
2999
+ * const exampleTargetGroup = new aws.lb.TargetGroup("example", {});
3000
+ * const exampleListener = new aws.lb.Listener("example", {
3001
+ * loadBalancerArn: example.id,
3002
+ * defaultActions: [{
3003
+ * targetGroupArn: exampleTargetGroup.id,
3004
+ * type: "forward",
3005
+ * }],
3006
+ * mutualAuthentication: {
3007
+ * mode: "verify",
3008
+ * trustStoreArn: "...",
3009
+ * },
3010
+ * });
3011
+ * ```
3012
+ * ```python
3013
+ * import pulumi
3014
+ * import pulumi_aws as aws
3015
+ *
3016
+ * example = aws.lb.LoadBalancer("example", load_balancer_type="application")
3017
+ * example_target_group = aws.lb.TargetGroup("example")
3018
+ * example_listener = aws.lb.Listener("example",
3019
+ * load_balancer_arn=example.id,
3020
+ * default_actions=[{
3021
+ * "target_group_arn": example_target_group.id,
3022
+ * "type": "forward",
3023
+ * }],
3024
+ * mutual_authentication={
3025
+ * "mode": "verify",
3026
+ * "trust_store_arn": "...",
3027
+ * })
3028
+ * ```
3029
+ * ```csharp
3030
+ * using System.Collections.Generic;
3031
+ * using System.Linq;
3032
+ * using Pulumi;
3033
+ * using Aws = Pulumi.Aws;
3034
+ *
3035
+ * return await Deployment.RunAsync(() =>
3036
+ * {
3037
+ * var example = new Aws.LB.LoadBalancer("example", new()
3038
+ * {
3039
+ * LoadBalancerType = "application",
3040
+ * });
3041
+ *
3042
+ * var exampleTargetGroup = new Aws.LB.TargetGroup("example");
3043
+ *
3044
+ * var exampleListener = new Aws.LB.Listener("example", new()
3045
+ * {
3046
+ * LoadBalancerArn = example.Id,
3047
+ * DefaultActions = new[]
3048
+ * {
3049
+ * new Aws.LB.Inputs.ListenerDefaultActionArgs
3050
+ * {
3051
+ * TargetGroupArn = exampleTargetGroup.Id,
3052
+ * Type = "forward",
3053
+ * },
3054
+ * },
3055
+ * MutualAuthentication = new Aws.LB.Inputs.ListenerMutualAuthenticationArgs
3056
+ * {
3057
+ * Mode = "verify",
3058
+ * TrustStoreArn = "...",
3059
+ * },
3060
+ * });
3061
+ *
3062
+ * });
3063
+ * ```
3064
+ * ```go
3065
+ * package main
3066
+ *
3067
+ * import (
3068
+ * "github.com/pulumi/pulumi-aws/sdk/v6/go/aws/lb"
3069
+ * "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
3070
+ * )
3071
+ *
3072
+ * func main() {
3073
+ * pulumi.Run(func(ctx *pulumi.Context) error {
3074
+ * example, err := lb.NewLoadBalancer(ctx, "example", &lb.LoadBalancerArgs{
3075
+ * LoadBalancerType: pulumi.String("application"),
3076
+ * })
3077
+ * if err != nil {
3078
+ * return err
3079
+ * }
3080
+ * exampleTargetGroup, err := lb.NewTargetGroup(ctx, "example", nil)
3081
+ * if err != nil {
3082
+ * return err
3083
+ * }
3084
+ * _, err = lb.NewListener(ctx, "example", &lb.ListenerArgs{
3085
+ * LoadBalancerArn: example.ID(),
3086
+ * DefaultActions: lb.ListenerDefaultActionArray{
3087
+ * &lb.ListenerDefaultActionArgs{
3088
+ * TargetGroupArn: exampleTargetGroup.ID(),
3089
+ * Type: pulumi.String("forward"),
3090
+ * },
3091
+ * },
3092
+ * MutualAuthentication: &lb.ListenerMutualAuthenticationArgs{
3093
+ * Mode: pulumi.String("verify"),
3094
+ * TrustStoreArn: pulumi.String("..."),
3095
+ * },
3096
+ * })
3097
+ * if err != nil {
3098
+ * return err
3099
+ * }
3100
+ * return nil
3101
+ * })
3102
+ * }
3103
+ * ```
3104
+ * ```java
3105
+ * package generated_program;
3106
+ *
3107
+ * import com.pulumi.Context;
3108
+ * import com.pulumi.Pulumi;
3109
+ * import com.pulumi.core.Output;
3110
+ * import com.pulumi.aws.lb.LoadBalancer;
3111
+ * import com.pulumi.aws.lb.LoadBalancerArgs;
3112
+ * import com.pulumi.aws.lb.TargetGroup;
3113
+ * import com.pulumi.aws.lb.Listener;
3114
+ * import com.pulumi.aws.lb.ListenerArgs;
3115
+ * import com.pulumi.aws.lb.inputs.ListenerDefaultActionArgs;
3116
+ * import com.pulumi.aws.lb.inputs.ListenerMutualAuthenticationArgs;
3117
+ * import java.util.List;
3118
+ * import java.util.ArrayList;
3119
+ * import java.util.Map;
3120
+ * import java.io.File;
3121
+ * import java.nio.file.Files;
3122
+ * import java.nio.file.Paths;
3123
+ *
3124
+ * public class App {
3125
+ * public static void main(String[] args) {
3126
+ * Pulumi.run(App::stack);
3127
+ * }
3128
+ *
3129
+ * public static void stack(Context ctx) {
3130
+ * var example = new LoadBalancer("example", LoadBalancerArgs.builder()
3131
+ * .loadBalancerType("application")
3132
+ * .build());
3133
+ *
3134
+ * var exampleTargetGroup = new TargetGroup("exampleTargetGroup");
3135
+ *
3136
+ * var exampleListener = new Listener("exampleListener", ListenerArgs.builder()
3137
+ * .loadBalancerArn(example.id())
3138
+ * .defaultActions(ListenerDefaultActionArgs.builder()
3139
+ * .targetGroupArn(exampleTargetGroup.id())
3140
+ * .type("forward")
3141
+ * .build())
3142
+ * .mutualAuthentication(ListenerMutualAuthenticationArgs.builder()
3143
+ * .mode("verify")
3144
+ * .trustStoreArn("...")
3145
+ * .build())
3146
+ * .build());
3147
+ *
3148
+ * }
3149
+ * }
3150
+ * ```
3151
+ * ```yaml
3152
+ * resources:
3153
+ * example:
3154
+ * type: aws:lb:LoadBalancer
3155
+ * properties:
3156
+ * loadBalancerType: application
3157
+ * exampleTargetGroup:
3158
+ * type: aws:lb:TargetGroup
3159
+ * name: example
3160
+ * exampleListener:
3161
+ * type: aws:lb:Listener
3162
+ * name: example
3163
+ * properties:
3164
+ * loadBalancerArn: ${example.id}
3165
+ * defaultActions:
3166
+ * - targetGroupArn: ${exampleTargetGroup.id}
3167
+ * type: forward
3168
+ * mutualAuthentication:
3169
+ * mode: verify
3170
+ * trustStoreArn: '...'
3171
+ * ```
3172
+ * <!--End PulumiCodeChooser -->
2775
3173
  *
2776
3174
  * ## Import
2777
3175
  *
2778
3176
  * Using `pulumi import`, import listeners using their ARN. For example:
2779
3177
  *
2780
3178
  * ```sh
2781
- * $ pulumi import aws:lb/listener:Listener front_end arn:aws:elasticloadbalancing:us-west-2:187416307283:listener/app/front-end-alb/8e4497da625e2d8a/9ab28ade35828f96
3179
+ * $ pulumi import aws:lb/listener:Listener front_end arn:aws:elasticloadbalancing:us-west-2:187416307283:listener/app/front-end-alb/8e4497da625e2d8a/9ab28ade35828f96
2782
3180
  * ```
2783
- *
2784
3181
  */
2785
3182
  interface ListenerArgs {
2786
3183
  /**
@@ -2792,9 +3189,13 @@ export declare namespace lb {
2792
3189
  */
2793
3190
  certificateArn?: pulumi.Input<string>;
2794
3191
  /**
2795
- * Configuration block for default actions. Detailed below.
3192
+ * Configuration block for default actions. See below.
2796
3193
  */
2797
3194
  defaultActions?: pulumi.Input<pulumi.Input<pulumiAws.types.input.lb.ListenerDefaultAction>[]>;
3195
+ /**
3196
+ * The mutual authentication configuration information. See below.
3197
+ */
3198
+ mutualAuthentication?: pulumi.Input<pulumiAws.types.input.lb.ListenerMutualAuthentication>;
2798
3199
  /**
2799
3200
  * Port on which the load balancer is listening. Not valid for Gateway Load Balancers.
2800
3201
  */
@@ -2804,34 +3205,39 @@ export declare namespace lb {
2804
3205
  */
2805
3206
  protocol?: pulumi.Input<string>;
2806
3207
  /**
2807
- * Name of the SSL Policy for the listener. Required if `protocol` is `HTTPS` or `TLS`.
3208
+ * Name of the SSL Policy for the listener. Required if `protocol` is `HTTPS` or `TLS`. Default is `ELBSecurityPolicy-2016-08`.
2808
3209
  */
2809
3210
  sslPolicy?: pulumi.Input<string>;
2810
3211
  /**
2811
3212
  * A map of tags to assign to the resource. .If configured with a provider `default_tags` configuration block present, tags with matching keys will overwrite those defined at the provider-level.
2812
3213
  *
2813
- * > **NOTE::** Please note that listeners that are attached to Application Load Balancers must use either `HTTP` or `HTTPS` protocols while listeners that are attached to Network Load Balancers must use the `TCP` protocol.
3214
+ * > **Note::** When a `Name` key is specified in the map, the AWS Console maps the value to the `Name Tag` column value inside the `Listener Rules` table within a specific load balancer listener page. Otherwise, the value resolves to `Default`.
2814
3215
  */
2815
3216
  tags?: pulumi.Input<{
2816
3217
  [key: string]: pulumi.Input<string>;
2817
3218
  }>;
3219
+ /**
3220
+ * TCP idle timeout value in seconds. Can only be set if protocol is `TCP` on Network Load Balancer, or with a Gateway Load Balancer. Not supported for Application Load Balancers. Valid values are between `60` and `6000` inclusive. Default: `350`.
3221
+ */
3222
+ tcpIdleTimeoutSeconds?: pulumi.Input<number>;
2818
3223
  }
2819
3224
  /**
2820
3225
  * Provides a Target Group resource for use with Load Balancer resources.
2821
3226
  *
2822
3227
  * > **Note:** `aws.alb.TargetGroup` is known as `aws.lb.TargetGroup`. The functionality is identical.
2823
3228
  *
2824
- * {{% examples %}}
2825
3229
  * ## Example Usage
2826
- * {{% example %}}
3230
+ *
2827
3231
  * ### Instance Target Group
2828
3232
  *
3233
+ * <!--Start PulumiCodeChooser -->
2829
3234
  * ```typescript
2830
3235
  * import * as pulumi from "@pulumi/pulumi";
2831
3236
  * import * as aws from "@pulumi/aws";
2832
3237
  *
2833
3238
  * const main = new aws.ec2.Vpc("main", {cidrBlock: "10.0.0.0/16"});
2834
3239
  * const test = new aws.lb.TargetGroup("test", {
3240
+ * name: "tf-example-lb-tg",
2835
3241
  * port: 80,
2836
3242
  * protocol: "HTTP",
2837
3243
  * vpcId: main.id,
@@ -2843,6 +3249,7 @@ export declare namespace lb {
2843
3249
  *
2844
3250
  * main = aws.ec2.Vpc("main", cidr_block="10.0.0.0/16")
2845
3251
  * test = aws.lb.TargetGroup("test",
3252
+ * name="tf-example-lb-tg",
2846
3253
  * port=80,
2847
3254
  * protocol="HTTP",
2848
3255
  * vpc_id=main.id)
@@ -2862,6 +3269,7 @@ export declare namespace lb {
2862
3269
  *
2863
3270
  * var test = new Aws.LB.TargetGroup("test", new()
2864
3271
  * {
3272
+ * Name = "tf-example-lb-tg",
2865
3273
  * Port = 80,
2866
3274
  * Protocol = "HTTP",
2867
3275
  * VpcId = main.Id,
@@ -2887,6 +3295,7 @@ export declare namespace lb {
2887
3295
  * return err
2888
3296
  * }
2889
3297
  * _, err = lb.NewTargetGroup(ctx, "test", &lb.TargetGroupArgs{
3298
+ * Name: pulumi.String("tf-example-lb-tg"),
2890
3299
  * Port: pulumi.Int(80),
2891
3300
  * Protocol: pulumi.String("HTTP"),
2892
3301
  * VpcId: main.ID(),
@@ -2926,6 +3335,7 @@ export declare namespace lb {
2926
3335
  * .build());
2927
3336
  *
2928
3337
  * var test = new TargetGroup("test", TargetGroupArgs.builder()
3338
+ * .name("tf-example-lb-tg")
2929
3339
  * .port(80)
2930
3340
  * .protocol("HTTP")
2931
3341
  * .vpcId(main.id())
@@ -2939,6 +3349,7 @@ export declare namespace lb {
2939
3349
  * test:
2940
3350
  * type: aws:lb:TargetGroup
2941
3351
  * properties:
3352
+ * name: tf-example-lb-tg
2942
3353
  * port: 80
2943
3354
  * protocol: HTTP
2944
3355
  * vpcId: ${main.id}
@@ -2947,16 +3358,18 @@ export declare namespace lb {
2947
3358
  * properties:
2948
3359
  * cidrBlock: 10.0.0.0/16
2949
3360
  * ```
2950
- * {{% /example %}}
2951
- * {{% example %}}
3361
+ * <!--End PulumiCodeChooser -->
3362
+ *
2952
3363
  * ### IP Target Group
2953
3364
  *
3365
+ * <!--Start PulumiCodeChooser -->
2954
3366
  * ```typescript
2955
3367
  * import * as pulumi from "@pulumi/pulumi";
2956
3368
  * import * as aws from "@pulumi/aws";
2957
3369
  *
2958
3370
  * const main = new aws.ec2.Vpc("main", {cidrBlock: "10.0.0.0/16"});
2959
3371
  * const ip_example = new aws.lb.TargetGroup("ip-example", {
3372
+ * name: "tf-example-lb-tg",
2960
3373
  * port: 80,
2961
3374
  * protocol: "HTTP",
2962
3375
  * targetType: "ip",
@@ -2969,6 +3382,7 @@ export declare namespace lb {
2969
3382
  *
2970
3383
  * main = aws.ec2.Vpc("main", cidr_block="10.0.0.0/16")
2971
3384
  * ip_example = aws.lb.TargetGroup("ip-example",
3385
+ * name="tf-example-lb-tg",
2972
3386
  * port=80,
2973
3387
  * protocol="HTTP",
2974
3388
  * target_type="ip",
@@ -2989,6 +3403,7 @@ export declare namespace lb {
2989
3403
  *
2990
3404
  * var ip_example = new Aws.LB.TargetGroup("ip-example", new()
2991
3405
  * {
3406
+ * Name = "tf-example-lb-tg",
2992
3407
  * Port = 80,
2993
3408
  * Protocol = "HTTP",
2994
3409
  * TargetType = "ip",
@@ -3015,6 +3430,7 @@ export declare namespace lb {
3015
3430
  * return err
3016
3431
  * }
3017
3432
  * _, err = lb.NewTargetGroup(ctx, "ip-example", &lb.TargetGroupArgs{
3433
+ * Name: pulumi.String("tf-example-lb-tg"),
3018
3434
  * Port: pulumi.Int(80),
3019
3435
  * Protocol: pulumi.String("HTTP"),
3020
3436
  * TargetType: pulumi.String("ip"),
@@ -3055,6 +3471,7 @@ export declare namespace lb {
3055
3471
  * .build());
3056
3472
  *
3057
3473
  * var ip_example = new TargetGroup("ip-example", TargetGroupArgs.builder()
3474
+ * .name("tf-example-lb-tg")
3058
3475
  * .port(80)
3059
3476
  * .protocol("HTTP")
3060
3477
  * .targetType("ip")
@@ -3069,6 +3486,7 @@ export declare namespace lb {
3069
3486
  * ip-example:
3070
3487
  * type: aws:lb:TargetGroup
3071
3488
  * properties:
3489
+ * name: tf-example-lb-tg
3072
3490
  * port: 80
3073
3491
  * protocol: HTTP
3074
3492
  * targetType: ip
@@ -3078,21 +3496,27 @@ export declare namespace lb {
3078
3496
  * properties:
3079
3497
  * cidrBlock: 10.0.0.0/16
3080
3498
  * ```
3081
- * {{% /example %}}
3082
- * {{% example %}}
3499
+ * <!--End PulumiCodeChooser -->
3500
+ *
3083
3501
  * ### Lambda Target Group
3084
3502
  *
3503
+ * <!--Start PulumiCodeChooser -->
3085
3504
  * ```typescript
3086
3505
  * import * as pulumi from "@pulumi/pulumi";
3087
3506
  * import * as aws from "@pulumi/aws";
3088
3507
  *
3089
- * const lambda_example = new aws.lb.TargetGroup("lambda-example", {targetType: "lambda"});
3508
+ * const lambda_example = new aws.lb.TargetGroup("lambda-example", {
3509
+ * name: "tf-example-lb-tg",
3510
+ * targetType: "lambda",
3511
+ * });
3090
3512
  * ```
3091
3513
  * ```python
3092
3514
  * import pulumi
3093
3515
  * import pulumi_aws as aws
3094
3516
  *
3095
- * lambda_example = aws.lb.TargetGroup("lambda-example", target_type="lambda")
3517
+ * lambda_example = aws.lb.TargetGroup("lambda-example",
3518
+ * name="tf-example-lb-tg",
3519
+ * target_type="lambda")
3096
3520
  * ```
3097
3521
  * ```csharp
3098
3522
  * using System.Collections.Generic;
@@ -3104,6 +3528,7 @@ export declare namespace lb {
3104
3528
  * {
3105
3529
  * var lambda_example = new Aws.LB.TargetGroup("lambda-example", new()
3106
3530
  * {
3531
+ * Name = "tf-example-lb-tg",
3107
3532
  * TargetType = "lambda",
3108
3533
  * });
3109
3534
  *
@@ -3120,6 +3545,7 @@ export declare namespace lb {
3120
3545
  * func main() {
3121
3546
  * pulumi.Run(func(ctx *pulumi.Context) error {
3122
3547
  * _, err := lb.NewTargetGroup(ctx, "lambda-example", &lb.TargetGroupArgs{
3548
+ * Name: pulumi.String("tf-example-lb-tg"),
3123
3549
  * TargetType: pulumi.String("lambda"),
3124
3550
  * })
3125
3551
  * if err != nil {
@@ -3151,6 +3577,7 @@ export declare namespace lb {
3151
3577
  *
3152
3578
  * public static void stack(Context ctx) {
3153
3579
  * var lambda_example = new TargetGroup("lambda-example", TargetGroupArgs.builder()
3580
+ * .name("tf-example-lb-tg")
3154
3581
  * .targetType("lambda")
3155
3582
  * .build());
3156
3583
  *
@@ -3162,21 +3589,24 @@ export declare namespace lb {
3162
3589
  * lambda-example:
3163
3590
  * type: aws:lb:TargetGroup
3164
3591
  * properties:
3592
+ * name: tf-example-lb-tg
3165
3593
  * targetType: lambda
3166
3594
  * ```
3167
- * {{% /example %}}
3168
- * {{% example %}}
3595
+ * <!--End PulumiCodeChooser -->
3596
+ *
3169
3597
  * ### ALB Target Group
3170
3598
  *
3599
+ * <!--Start PulumiCodeChooser -->
3171
3600
  * ```typescript
3172
3601
  * import * as pulumi from "@pulumi/pulumi";
3173
3602
  * import * as aws from "@pulumi/aws";
3174
3603
  *
3175
3604
  * const alb_example = new aws.lb.TargetGroup("alb-example", {
3605
+ * name: "tf-example-lb-alb-tg",
3176
3606
  * targetType: "alb",
3177
3607
  * port: 80,
3178
3608
  * protocol: "TCP",
3179
- * vpcId: aws_vpc.main.id,
3609
+ * vpcId: main.id,
3180
3610
  * });
3181
3611
  * ```
3182
3612
  * ```python
@@ -3184,10 +3614,11 @@ export declare namespace lb {
3184
3614
  * import pulumi_aws as aws
3185
3615
  *
3186
3616
  * alb_example = aws.lb.TargetGroup("alb-example",
3617
+ * name="tf-example-lb-alb-tg",
3187
3618
  * target_type="alb",
3188
3619
  * port=80,
3189
3620
  * protocol="TCP",
3190
- * vpc_id=aws_vpc["main"]["id"])
3621
+ * vpc_id=main["id"])
3191
3622
  * ```
3192
3623
  * ```csharp
3193
3624
  * using System.Collections.Generic;
@@ -3199,10 +3630,11 @@ export declare namespace lb {
3199
3630
  * {
3200
3631
  * var alb_example = new Aws.LB.TargetGroup("alb-example", new()
3201
3632
  * {
3633
+ * Name = "tf-example-lb-alb-tg",
3202
3634
  * TargetType = "alb",
3203
3635
  * Port = 80,
3204
3636
  * Protocol = "TCP",
3205
- * VpcId = aws_vpc.Main.Id,
3637
+ * VpcId = main.Id,
3206
3638
  * });
3207
3639
  *
3208
3640
  * });
@@ -3218,10 +3650,11 @@ export declare namespace lb {
3218
3650
  * func main() {
3219
3651
  * pulumi.Run(func(ctx *pulumi.Context) error {
3220
3652
  * _, err := lb.NewTargetGroup(ctx, "alb-example", &lb.TargetGroupArgs{
3653
+ * Name: pulumi.String("tf-example-lb-alb-tg"),
3221
3654
  * TargetType: pulumi.String("alb"),
3222
3655
  * Port: pulumi.Int(80),
3223
3656
  * Protocol: pulumi.String("TCP"),
3224
- * VpcId: pulumi.Any(aws_vpc.Main.Id),
3657
+ * VpcId: pulumi.Any(main.Id),
3225
3658
  * })
3226
3659
  * if err != nil {
3227
3660
  * return err
@@ -3252,10 +3685,11 @@ export declare namespace lb {
3252
3685
  *
3253
3686
  * public static void stack(Context ctx) {
3254
3687
  * var alb_example = new TargetGroup("alb-example", TargetGroupArgs.builder()
3688
+ * .name("tf-example-lb-alb-tg")
3255
3689
  * .targetType("alb")
3256
3690
  * .port(80)
3257
3691
  * .protocol("TCP")
3258
- * .vpcId(aws_vpc.main().id())
3692
+ * .vpcId(main.id())
3259
3693
  * .build());
3260
3694
  *
3261
3695
  * }
@@ -3266,23 +3700,26 @@ export declare namespace lb {
3266
3700
  * alb-example:
3267
3701
  * type: aws:lb:TargetGroup
3268
3702
  * properties:
3703
+ * name: tf-example-lb-alb-tg
3269
3704
  * targetType: alb
3270
3705
  * port: 80
3271
3706
  * protocol: TCP
3272
- * vpcId: ${aws_vpc.main.id}
3707
+ * vpcId: ${main.id}
3273
3708
  * ```
3274
- * {{% /example %}}
3275
- * {{% example %}}
3709
+ * <!--End PulumiCodeChooser -->
3710
+ *
3276
3711
  * ### Target group with unhealthy connection termination disabled
3277
3712
  *
3713
+ * <!--Start PulumiCodeChooser -->
3278
3714
  * ```typescript
3279
3715
  * import * as pulumi from "@pulumi/pulumi";
3280
3716
  * import * as aws from "@pulumi/aws";
3281
3717
  *
3282
3718
  * const tcp_example = new aws.lb.TargetGroup("tcp-example", {
3719
+ * name: "tf-example-lb-nlb-tg",
3283
3720
  * port: 25,
3284
3721
  * protocol: "TCP",
3285
- * vpcId: aws_vpc.main.id,
3722
+ * vpcId: main.id,
3286
3723
  * targetHealthStates: [{
3287
3724
  * enableUnhealthyConnectionTermination: false,
3288
3725
  * }],
@@ -3293,12 +3730,13 @@ export declare namespace lb {
3293
3730
  * import pulumi_aws as aws
3294
3731
  *
3295
3732
  * tcp_example = aws.lb.TargetGroup("tcp-example",
3733
+ * name="tf-example-lb-nlb-tg",
3296
3734
  * port=25,
3297
3735
  * protocol="TCP",
3298
- * vpc_id=aws_vpc["main"]["id"],
3299
- * target_health_states=[aws.lb.TargetGroupTargetHealthStateArgs(
3300
- * enable_unhealthy_connection_termination=False,
3301
- * )])
3736
+ * vpc_id=main["id"],
3737
+ * target_health_states=[{
3738
+ * "enable_unhealthy_connection_termination": False,
3739
+ * }])
3302
3740
  * ```
3303
3741
  * ```csharp
3304
3742
  * using System.Collections.Generic;
@@ -3310,9 +3748,10 @@ export declare namespace lb {
3310
3748
  * {
3311
3749
  * var tcp_example = new Aws.LB.TargetGroup("tcp-example", new()
3312
3750
  * {
3751
+ * Name = "tf-example-lb-nlb-tg",
3313
3752
  * Port = 25,
3314
3753
  * Protocol = "TCP",
3315
- * VpcId = aws_vpc.Main.Id,
3754
+ * VpcId = main.Id,
3316
3755
  * TargetHealthStates = new[]
3317
3756
  * {
3318
3757
  * new Aws.LB.Inputs.TargetGroupTargetHealthStateArgs
@@ -3335,9 +3774,10 @@ export declare namespace lb {
3335
3774
  * func main() {
3336
3775
  * pulumi.Run(func(ctx *pulumi.Context) error {
3337
3776
  * _, err := lb.NewTargetGroup(ctx, "tcp-example", &lb.TargetGroupArgs{
3777
+ * Name: pulumi.String("tf-example-lb-nlb-tg"),
3338
3778
  * Port: pulumi.Int(25),
3339
3779
  * Protocol: pulumi.String("TCP"),
3340
- * VpcId: pulumi.Any(aws_vpc.Main.Id),
3780
+ * VpcId: pulumi.Any(main.Id),
3341
3781
  * TargetHealthStates: lb.TargetGroupTargetHealthStateArray{
3342
3782
  * &lb.TargetGroupTargetHealthStateArgs{
3343
3783
  * EnableUnhealthyConnectionTermination: pulumi.Bool(false),
@@ -3374,9 +3814,10 @@ export declare namespace lb {
3374
3814
  *
3375
3815
  * public static void stack(Context ctx) {
3376
3816
  * var tcp_example = new TargetGroup("tcp-example", TargetGroupArgs.builder()
3817
+ * .name("tf-example-lb-nlb-tg")
3377
3818
  * .port(25)
3378
3819
  * .protocol("TCP")
3379
- * .vpcId(aws_vpc.main().id())
3820
+ * .vpcId(main.id())
3380
3821
  * .targetHealthStates(TargetGroupTargetHealthStateArgs.builder()
3381
3822
  * .enableUnhealthyConnectionTermination(false)
3382
3823
  * .build())
@@ -3390,23 +3831,193 @@ export declare namespace lb {
3390
3831
  * tcp-example:
3391
3832
  * type: aws:lb:TargetGroup
3392
3833
  * properties:
3834
+ * name: tf-example-lb-nlb-tg
3393
3835
  * port: 25
3394
3836
  * protocol: TCP
3395
- * vpcId: ${aws_vpc.main.id}
3837
+ * vpcId: ${main.id}
3396
3838
  * targetHealthStates:
3397
3839
  * - enableUnhealthyConnectionTermination: false
3398
3840
  * ```
3399
- * {{% /example %}}
3400
- * {{% /examples %}}
3841
+ * <!--End PulumiCodeChooser -->
3842
+ *
3843
+ * ### Target group with health requirements
3844
+ *
3845
+ * <!--Start PulumiCodeChooser -->
3846
+ * ```typescript
3847
+ * import * as pulumi from "@pulumi/pulumi";
3848
+ * import * as aws from "@pulumi/aws";
3849
+ *
3850
+ * const tcp_example = new aws.lb.TargetGroup("tcp-example", {
3851
+ * name: "tf-example-lb-nlb-tg",
3852
+ * port: 80,
3853
+ * protocol: "TCP",
3854
+ * vpcId: main.id,
3855
+ * targetGroupHealth: {
3856
+ * dnsFailover: {
3857
+ * minimumHealthyTargetsCount: "1",
3858
+ * minimumHealthyTargetsPercentage: "off",
3859
+ * },
3860
+ * unhealthyStateRouting: {
3861
+ * minimumHealthyTargetsCount: 1,
3862
+ * minimumHealthyTargetsPercentage: "off",
3863
+ * },
3864
+ * },
3865
+ * });
3866
+ * ```
3867
+ * ```python
3868
+ * import pulumi
3869
+ * import pulumi_aws as aws
3870
+ *
3871
+ * tcp_example = aws.lb.TargetGroup("tcp-example",
3872
+ * name="tf-example-lb-nlb-tg",
3873
+ * port=80,
3874
+ * protocol="TCP",
3875
+ * vpc_id=main["id"],
3876
+ * target_group_health={
3877
+ * "dns_failover": {
3878
+ * "minimum_healthy_targets_count": "1",
3879
+ * "minimum_healthy_targets_percentage": "off",
3880
+ * },
3881
+ * "unhealthy_state_routing": {
3882
+ * "minimum_healthy_targets_count": 1,
3883
+ * "minimum_healthy_targets_percentage": "off",
3884
+ * },
3885
+ * })
3886
+ * ```
3887
+ * ```csharp
3888
+ * using System.Collections.Generic;
3889
+ * using System.Linq;
3890
+ * using Pulumi;
3891
+ * using Aws = Pulumi.Aws;
3892
+ *
3893
+ * return await Deployment.RunAsync(() =>
3894
+ * {
3895
+ * var tcp_example = new Aws.LB.TargetGroup("tcp-example", new()
3896
+ * {
3897
+ * Name = "tf-example-lb-nlb-tg",
3898
+ * Port = 80,
3899
+ * Protocol = "TCP",
3900
+ * VpcId = main.Id,
3901
+ * TargetGroupHealth = new Aws.LB.Inputs.TargetGroupTargetGroupHealthArgs
3902
+ * {
3903
+ * DnsFailover = new Aws.LB.Inputs.TargetGroupTargetGroupHealthDnsFailoverArgs
3904
+ * {
3905
+ * MinimumHealthyTargetsCount = "1",
3906
+ * MinimumHealthyTargetsPercentage = "off",
3907
+ * },
3908
+ * UnhealthyStateRouting = new Aws.LB.Inputs.TargetGroupTargetGroupHealthUnhealthyStateRoutingArgs
3909
+ * {
3910
+ * MinimumHealthyTargetsCount = 1,
3911
+ * MinimumHealthyTargetsPercentage = "off",
3912
+ * },
3913
+ * },
3914
+ * });
3915
+ *
3916
+ * });
3917
+ * ```
3918
+ * ```go
3919
+ * package main
3920
+ *
3921
+ * import (
3922
+ * "github.com/pulumi/pulumi-aws/sdk/v6/go/aws/lb"
3923
+ * "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
3924
+ * )
3925
+ *
3926
+ * func main() {
3927
+ * pulumi.Run(func(ctx *pulumi.Context) error {
3928
+ * _, err := lb.NewTargetGroup(ctx, "tcp-example", &lb.TargetGroupArgs{
3929
+ * Name: pulumi.String("tf-example-lb-nlb-tg"),
3930
+ * Port: pulumi.Int(80),
3931
+ * Protocol: pulumi.String("TCP"),
3932
+ * VpcId: pulumi.Any(main.Id),
3933
+ * TargetGroupHealth: &lb.TargetGroupTargetGroupHealthArgs{
3934
+ * DnsFailover: &lb.TargetGroupTargetGroupHealthDnsFailoverArgs{
3935
+ * MinimumHealthyTargetsCount: pulumi.String("1"),
3936
+ * MinimumHealthyTargetsPercentage: pulumi.String("off"),
3937
+ * },
3938
+ * UnhealthyStateRouting: &lb.TargetGroupTargetGroupHealthUnhealthyStateRoutingArgs{
3939
+ * MinimumHealthyTargetsCount: pulumi.Int(1),
3940
+ * MinimumHealthyTargetsPercentage: pulumi.String("off"),
3941
+ * },
3942
+ * },
3943
+ * })
3944
+ * if err != nil {
3945
+ * return err
3946
+ * }
3947
+ * return nil
3948
+ * })
3949
+ * }
3950
+ * ```
3951
+ * ```java
3952
+ * package generated_program;
3953
+ *
3954
+ * import com.pulumi.Context;
3955
+ * import com.pulumi.Pulumi;
3956
+ * import com.pulumi.core.Output;
3957
+ * import com.pulumi.aws.lb.TargetGroup;
3958
+ * import com.pulumi.aws.lb.TargetGroupArgs;
3959
+ * import com.pulumi.aws.lb.inputs.TargetGroupTargetGroupHealthArgs;
3960
+ * import com.pulumi.aws.lb.inputs.TargetGroupTargetGroupHealthDnsFailoverArgs;
3961
+ * import com.pulumi.aws.lb.inputs.TargetGroupTargetGroupHealthUnhealthyStateRoutingArgs;
3962
+ * import java.util.List;
3963
+ * import java.util.ArrayList;
3964
+ * import java.util.Map;
3965
+ * import java.io.File;
3966
+ * import java.nio.file.Files;
3967
+ * import java.nio.file.Paths;
3968
+ *
3969
+ * public class App {
3970
+ * public static void main(String[] args) {
3971
+ * Pulumi.run(App::stack);
3972
+ * }
3973
+ *
3974
+ * public static void stack(Context ctx) {
3975
+ * var tcp_example = new TargetGroup("tcp-example", TargetGroupArgs.builder()
3976
+ * .name("tf-example-lb-nlb-tg")
3977
+ * .port(80)
3978
+ * .protocol("TCP")
3979
+ * .vpcId(main.id())
3980
+ * .targetGroupHealth(TargetGroupTargetGroupHealthArgs.builder()
3981
+ * .dnsFailover(TargetGroupTargetGroupHealthDnsFailoverArgs.builder()
3982
+ * .minimumHealthyTargetsCount("1")
3983
+ * .minimumHealthyTargetsPercentage("off")
3984
+ * .build())
3985
+ * .unhealthyStateRouting(TargetGroupTargetGroupHealthUnhealthyStateRoutingArgs.builder()
3986
+ * .minimumHealthyTargetsCount("1")
3987
+ * .minimumHealthyTargetsPercentage("off")
3988
+ * .build())
3989
+ * .build())
3990
+ * .build());
3991
+ *
3992
+ * }
3993
+ * }
3994
+ * ```
3995
+ * ```yaml
3996
+ * resources:
3997
+ * tcp-example:
3998
+ * type: aws:lb:TargetGroup
3999
+ * properties:
4000
+ * name: tf-example-lb-nlb-tg
4001
+ * port: 80
4002
+ * protocol: TCP
4003
+ * vpcId: ${main.id}
4004
+ * targetGroupHealth:
4005
+ * dnsFailover:
4006
+ * minimumHealthyTargetsCount: '1'
4007
+ * minimumHealthyTargetsPercentage: off
4008
+ * unhealthyStateRouting:
4009
+ * minimumHealthyTargetsCount: '1'
4010
+ * minimumHealthyTargetsPercentage: off
4011
+ * ```
4012
+ * <!--End PulumiCodeChooser -->
3401
4013
  *
3402
4014
  * ## Import
3403
4015
  *
3404
4016
  * Using `pulumi import`, import Target Groups using their ARN. For example:
3405
4017
  *
3406
4018
  * ```sh
3407
- * $ pulumi import aws:lb/targetGroup:TargetGroup app_front_end arn:aws:elasticloadbalancing:us-west-2:187416307283:targetgroup/app-front-end/20cfe21448b66314
4019
+ * $ pulumi import aws:lb/targetGroup:TargetGroup app_front_end arn:aws:elasticloadbalancing:us-west-2:187416307283:targetgroup/app-front-end/20cfe21448b66314
3408
4020
  * ```
3409
- *
3410
4021
  */
3411
4022
  interface TargetGroupArgs {
3412
4023
  /**
@@ -3430,9 +4041,13 @@ export declare namespace lb {
3430
4041
  */
3431
4042
  lambdaMultiValueHeadersEnabled?: pulumi.Input<boolean>;
3432
4043
  /**
3433
- * Determines how the load balancer selects targets when routing requests. Only applicable for Application Load Balancer Target Groups. The value is `round_robin` or `least_outstanding_requests`. The default is `round_robin`.
4044
+ * Determines how the load balancer selects targets when routing requests. Only applicable for Application Load Balancer Target Groups. The value is `round_robin`, `least_outstanding_requests`, or `weighted_random`. The default is `round_robin`.
3434
4045
  */
3435
4046
  loadBalancingAlgorithmType?: pulumi.Input<string>;
4047
+ /**
4048
+ * Determines whether to enable target anomaly mitigation. Target anomaly mitigation is only supported by the `weighted_random` load balancing algorithm type. See [doc](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-target-groups.html#automatic-target-weights) for more information. The value is `"on"` or `"off"`. The default is `"off"`.
4049
+ */
4050
+ loadBalancingAnomalyMitigation?: pulumi.Input<string>;
3436
4051
  /**
3437
4052
  * Indicates whether cross zone load balancing is enabled. The value is `"true"`, `"false"` or `"use_load_balancer_configuration"`. The default is `"use_load_balancer_configuration"`.
3438
4053
  */
@@ -3454,7 +4069,10 @@ export declare namespace lb {
3454
4069
  */
3455
4070
  preserveClientIp?: pulumi.Input<string>;
3456
4071
  /**
3457
- * Protocol to use for routing traffic to the targets. Should be one of `GENEVE`, `HTTP`, `HTTPS`, `TCP`, `TCP_UDP`, `TLS`, or `UDP`. Required when `target_type` is `instance`, `ip` or `alb`. Does not apply when `target_type` is `lambda`.
4072
+ * Protocol to use for routing traffic to the targets.
4073
+ * Should be one of `GENEVE`, `HTTP`, `HTTPS`, `TCP`, `TCP_UDP`, `TLS`, or `UDP`.
4074
+ * Required when `target_type` is `instance`, `ip`, or `alb`.
4075
+ * Does not apply when `target_type` is `lambda`.
3458
4076
  */
3459
4077
  protocol?: pulumi.Input<string>;
3460
4078
  /**
@@ -3483,12 +4101,18 @@ export declare namespace lb {
3483
4101
  * Target failover block. Only applicable for Gateway Load Balancer target groups. See target_failover for more information.
3484
4102
  */
3485
4103
  targetFailovers?: pulumi.Input<pulumi.Input<pulumiAws.types.input.lb.TargetGroupTargetFailover>[]>;
4104
+ /**
4105
+ * Target health requirements block. See target_group_health for more information.
4106
+ */
4107
+ targetGroupHealth?: pulumi.Input<pulumiAws.types.input.lb.TargetGroupTargetGroupHealth>;
3486
4108
  /**
3487
4109
  * Target health state block. Only applicable for Network Load Balancer target groups when `protocol` is `TCP` or `TLS`. See target_health_state for more information.
3488
4110
  */
3489
4111
  targetHealthStates?: pulumi.Input<pulumi.Input<pulumiAws.types.input.lb.TargetGroupTargetHealthState>[]>;
3490
4112
  /**
3491
- * Type of target that you must specify when registering targets with this target group. See [doc](https://docs.aws.amazon.com/elasticloadbalancing/latest/APIReference/API_CreateTargetGroup.html) for supported values. The default is `instance`.
4113
+ * Type of target that you must specify when registering targets with this target group.
4114
+ * See [doc](https://docs.aws.amazon.com/elasticloadbalancing/latest/APIReference/API_CreateTargetGroup.html) for supported values.
4115
+ * The default is `instance`.
3492
4116
  *
3493
4117
  * Note that you can't specify targets for a target group using both instance IDs and IP addresses.
3494
4118
  *