@pulumi/awsx 1.0.0-alpha.1651587948 → 1.0.0-alpha.1652201894
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.
- package/package.json +2 -2
- package/package.json.dev +2 -2
- package/types/input.d.ts +552 -7
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@pulumi/awsx",
|
|
3
|
-
"version": "v1.0.0-alpha.
|
|
3
|
+
"version": "v1.0.0-alpha.1652201894+3d599fa9",
|
|
4
4
|
"keywords": [
|
|
5
5
|
"pulumi",
|
|
6
6
|
"aws",
|
|
@@ -11,7 +11,7 @@
|
|
|
11
11
|
"license": "Apache-2.0",
|
|
12
12
|
"scripts": {
|
|
13
13
|
"build": "tsc",
|
|
14
|
-
"install": "node scripts/install-pulumi-plugin.js resource awsx v1.0.0-alpha.
|
|
14
|
+
"install": "node scripts/install-pulumi-plugin.js resource awsx v1.0.0-alpha.1652201894+3d599fa9"
|
|
15
15
|
},
|
|
16
16
|
"dependencies": {
|
|
17
17
|
"@pulumi/aws": "^5.3.0",
|
package/package.json.dev
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@pulumi/awsx",
|
|
3
|
-
"version": "v1.0.0-alpha.
|
|
3
|
+
"version": "v1.0.0-alpha.1652201894+3d599fa9",
|
|
4
4
|
"keywords": [
|
|
5
5
|
"pulumi",
|
|
6
6
|
"aws",
|
|
@@ -11,7 +11,7 @@
|
|
|
11
11
|
"license": "Apache-2.0",
|
|
12
12
|
"scripts": {
|
|
13
13
|
"build": "tsc",
|
|
14
|
-
"install": "node scripts/install-pulumi-plugin.js resource awsx v1.0.0-alpha.
|
|
14
|
+
"install": "node scripts/install-pulumi-plugin.js resource awsx v1.0.0-alpha.1652201894+3d599fa9"
|
|
15
15
|
},
|
|
16
16
|
"dependencies": {
|
|
17
17
|
"@pulumi/aws": "^5.3.0",
|
package/types/input.d.ts
CHANGED
|
@@ -786,7 +786,7 @@ export declare namespace lb {
|
|
|
786
786
|
* // ...
|
|
787
787
|
* const frontEndListener = new aws.lb.Listener("frontEndListener", {
|
|
788
788
|
* loadBalancerArn: frontEndLoadBalancer.arn,
|
|
789
|
-
* port:
|
|
789
|
+
* port: 443,
|
|
790
790
|
* protocol: "HTTPS",
|
|
791
791
|
* sslPolicy: "ELBSecurityPolicy-2016-08",
|
|
792
792
|
* certificateArn: "arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4",
|
|
@@ -889,6 +889,57 @@ export declare namespace lb {
|
|
|
889
889
|
* })
|
|
890
890
|
* }
|
|
891
891
|
* ```
|
|
892
|
+
* ```java
|
|
893
|
+
* package generated_program;
|
|
894
|
+
*
|
|
895
|
+
* import java.util.*;
|
|
896
|
+
* import java.io.*;
|
|
897
|
+
* import java.nio.*;
|
|
898
|
+
* import com.pulumi.*;
|
|
899
|
+
*
|
|
900
|
+
* public class App {
|
|
901
|
+
* public static void main(String[] args) {
|
|
902
|
+
* Pulumi.run(App::stack);
|
|
903
|
+
* }
|
|
904
|
+
*
|
|
905
|
+
* public static void stack(Context ctx) {
|
|
906
|
+
* var frontEndLoadBalancer = new LoadBalancer("frontEndLoadBalancer");
|
|
907
|
+
*
|
|
908
|
+
* var frontEndTargetGroup = new TargetGroup("frontEndTargetGroup");
|
|
909
|
+
*
|
|
910
|
+
* var frontEndListener = new Listener("frontEndListener", ListenerArgs.builder()
|
|
911
|
+
* .loadBalancerArn(frontEndLoadBalancer.getArn())
|
|
912
|
+
* .port("443")
|
|
913
|
+
* .protocol("HTTPS")
|
|
914
|
+
* .sslPolicy("ELBSecurityPolicy-2016-08")
|
|
915
|
+
* .certificateArn("arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4")
|
|
916
|
+
* .defaultActions(ListenerDefaultAction.builder()
|
|
917
|
+
* .type("forward")
|
|
918
|
+
* .targetGroupArn(frontEndTargetGroup.getArn())
|
|
919
|
+
* .build())
|
|
920
|
+
* .build());
|
|
921
|
+
*
|
|
922
|
+
* }
|
|
923
|
+
* }
|
|
924
|
+
* ```
|
|
925
|
+
* ```yaml
|
|
926
|
+
* resources:
|
|
927
|
+
* frontEndLoadBalancer:
|
|
928
|
+
* type: aws:lb:LoadBalancer
|
|
929
|
+
* frontEndTargetGroup:
|
|
930
|
+
* type: aws:lb:TargetGroup
|
|
931
|
+
* frontEndListener:
|
|
932
|
+
* type: aws:lb:Listener
|
|
933
|
+
* properties:
|
|
934
|
+
* loadBalancerArn: ${frontEndLoadBalancer.arn}
|
|
935
|
+
* port: 443
|
|
936
|
+
* protocol: HTTPS
|
|
937
|
+
* sslPolicy: ELBSecurityPolicy-2016-08
|
|
938
|
+
* certificateArn: arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4
|
|
939
|
+
* defaultActions:
|
|
940
|
+
* - type: forward
|
|
941
|
+
* targetGroupArn: ${frontEndTargetGroup.arn}
|
|
942
|
+
* ```
|
|
892
943
|
*
|
|
893
944
|
* To a NLB:
|
|
894
945
|
*
|
|
@@ -898,7 +949,7 @@ export declare namespace lb {
|
|
|
898
949
|
*
|
|
899
950
|
* const frontEnd = new aws.lb.Listener("frontEnd", {
|
|
900
951
|
* loadBalancerArn: aws_lb.front_end.arn,
|
|
901
|
-
* port:
|
|
952
|
+
* port: 443,
|
|
902
953
|
* protocol: "TLS",
|
|
903
954
|
* certificateArn: "arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4",
|
|
904
955
|
* alpnPolicy: "HTTP2Preferred",
|
|
@@ -981,6 +1032,49 @@ export declare namespace lb {
|
|
|
981
1032
|
* })
|
|
982
1033
|
* }
|
|
983
1034
|
* ```
|
|
1035
|
+
* ```java
|
|
1036
|
+
* package generated_program;
|
|
1037
|
+
*
|
|
1038
|
+
* import java.util.*;
|
|
1039
|
+
* import java.io.*;
|
|
1040
|
+
* import java.nio.*;
|
|
1041
|
+
* import com.pulumi.*;
|
|
1042
|
+
*
|
|
1043
|
+
* public class App {
|
|
1044
|
+
* public static void main(String[] args) {
|
|
1045
|
+
* Pulumi.run(App::stack);
|
|
1046
|
+
* }
|
|
1047
|
+
*
|
|
1048
|
+
* public static void stack(Context ctx) {
|
|
1049
|
+
* var frontEnd = new Listener("frontEnd", ListenerArgs.builder()
|
|
1050
|
+
* .loadBalancerArn(aws_lb.getFront_end().getArn())
|
|
1051
|
+
* .port("443")
|
|
1052
|
+
* .protocol("TLS")
|
|
1053
|
+
* .certificateArn("arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4")
|
|
1054
|
+
* .alpnPolicy("HTTP2Preferred")
|
|
1055
|
+
* .defaultActions(ListenerDefaultAction.builder()
|
|
1056
|
+
* .type("forward")
|
|
1057
|
+
* .targetGroupArn(aws_lb_target_group.getFront_end().getArn())
|
|
1058
|
+
* .build())
|
|
1059
|
+
* .build());
|
|
1060
|
+
*
|
|
1061
|
+
* }
|
|
1062
|
+
* }
|
|
1063
|
+
* ```
|
|
1064
|
+
* ```yaml
|
|
1065
|
+
* resources:
|
|
1066
|
+
* frontEnd:
|
|
1067
|
+
* type: aws:lb:Listener
|
|
1068
|
+
* properties:
|
|
1069
|
+
* loadBalancerArn: ${aws_lb.front_end.arn}
|
|
1070
|
+
* port: 443
|
|
1071
|
+
* protocol: TLS
|
|
1072
|
+
* certificateArn: arn:aws:iam::187416307283:server-certificate/test_cert_rab3wuqwgja25ct3n4jdj2tzu4
|
|
1073
|
+
* alpnPolicy: HTTP2Preferred
|
|
1074
|
+
* defaultActions:
|
|
1075
|
+
* - type: forward
|
|
1076
|
+
* targetGroupArn: ${aws_lb_target_group.front_end.arn}
|
|
1077
|
+
* ```
|
|
984
1078
|
* {{% /example %}}
|
|
985
1079
|
* {{% example %}}
|
|
986
1080
|
* ### Redirect Action
|
|
@@ -993,7 +1087,7 @@ export declare namespace lb {
|
|
|
993
1087
|
* // ...
|
|
994
1088
|
* const frontEndListener = new aws.lb.Listener("frontEndListener", {
|
|
995
1089
|
* loadBalancerArn: frontEndLoadBalancer.arn,
|
|
996
|
-
* port:
|
|
1090
|
+
* port: 80,
|
|
997
1091
|
* protocol: "HTTP",
|
|
998
1092
|
* defaultActions: [{
|
|
999
1093
|
* type: "redirect",
|
|
@@ -1095,6 +1189,56 @@ export declare namespace lb {
|
|
|
1095
1189
|
* })
|
|
1096
1190
|
* }
|
|
1097
1191
|
* ```
|
|
1192
|
+
* ```java
|
|
1193
|
+
* package generated_program;
|
|
1194
|
+
*
|
|
1195
|
+
* import java.util.*;
|
|
1196
|
+
* import java.io.*;
|
|
1197
|
+
* import java.nio.*;
|
|
1198
|
+
* import com.pulumi.*;
|
|
1199
|
+
*
|
|
1200
|
+
* public class App {
|
|
1201
|
+
* public static void main(String[] args) {
|
|
1202
|
+
* Pulumi.run(App::stack);
|
|
1203
|
+
* }
|
|
1204
|
+
*
|
|
1205
|
+
* public static void stack(Context ctx) {
|
|
1206
|
+
* var frontEndLoadBalancer = new LoadBalancer("frontEndLoadBalancer");
|
|
1207
|
+
*
|
|
1208
|
+
* var frontEndListener = new Listener("frontEndListener", ListenerArgs.builder()
|
|
1209
|
+
* .loadBalancerArn(frontEndLoadBalancer.getArn())
|
|
1210
|
+
* .port("80")
|
|
1211
|
+
* .protocol("HTTP")
|
|
1212
|
+
* .defaultActions(ListenerDefaultAction.builder()
|
|
1213
|
+
* .type("redirect")
|
|
1214
|
+
* .redirect(ListenerDefaultActionRedirect.builder()
|
|
1215
|
+
* .port("443")
|
|
1216
|
+
* .protocol("HTTPS")
|
|
1217
|
+
* .statusCode("HTTP_301")
|
|
1218
|
+
* .build())
|
|
1219
|
+
* .build())
|
|
1220
|
+
* .build());
|
|
1221
|
+
*
|
|
1222
|
+
* }
|
|
1223
|
+
* }
|
|
1224
|
+
* ```
|
|
1225
|
+
* ```yaml
|
|
1226
|
+
* resources:
|
|
1227
|
+
* frontEndLoadBalancer:
|
|
1228
|
+
* type: aws:lb:LoadBalancer
|
|
1229
|
+
* frontEndListener:
|
|
1230
|
+
* type: aws:lb:Listener
|
|
1231
|
+
* properties:
|
|
1232
|
+
* loadBalancerArn: ${frontEndLoadBalancer.arn}
|
|
1233
|
+
* port: 80
|
|
1234
|
+
* protocol: HTTP
|
|
1235
|
+
* defaultActions:
|
|
1236
|
+
* - type: redirect
|
|
1237
|
+
* redirect:
|
|
1238
|
+
* port: 443
|
|
1239
|
+
* protocol: HTTPS
|
|
1240
|
+
* statusCode: HTTP_301
|
|
1241
|
+
* ```
|
|
1098
1242
|
* {{% /example %}}
|
|
1099
1243
|
* {{% example %}}
|
|
1100
1244
|
* ### Fixed-response Action
|
|
@@ -1107,7 +1251,7 @@ export declare namespace lb {
|
|
|
1107
1251
|
* // ...
|
|
1108
1252
|
* const frontEndListener = new aws.lb.Listener("frontEndListener", {
|
|
1109
1253
|
* loadBalancerArn: frontEndLoadBalancer.arn,
|
|
1110
|
-
* port:
|
|
1254
|
+
* port: 80,
|
|
1111
1255
|
* protocol: "HTTP",
|
|
1112
1256
|
* defaultActions: [{
|
|
1113
1257
|
* type: "fixed-response",
|
|
@@ -1209,6 +1353,56 @@ export declare namespace lb {
|
|
|
1209
1353
|
* })
|
|
1210
1354
|
* }
|
|
1211
1355
|
* ```
|
|
1356
|
+
* ```java
|
|
1357
|
+
* package generated_program;
|
|
1358
|
+
*
|
|
1359
|
+
* import java.util.*;
|
|
1360
|
+
* import java.io.*;
|
|
1361
|
+
* import java.nio.*;
|
|
1362
|
+
* import com.pulumi.*;
|
|
1363
|
+
*
|
|
1364
|
+
* public class App {
|
|
1365
|
+
* public static void main(String[] args) {
|
|
1366
|
+
* Pulumi.run(App::stack);
|
|
1367
|
+
* }
|
|
1368
|
+
*
|
|
1369
|
+
* public static void stack(Context ctx) {
|
|
1370
|
+
* var frontEndLoadBalancer = new LoadBalancer("frontEndLoadBalancer");
|
|
1371
|
+
*
|
|
1372
|
+
* var frontEndListener = new Listener("frontEndListener", ListenerArgs.builder()
|
|
1373
|
+
* .loadBalancerArn(frontEndLoadBalancer.getArn())
|
|
1374
|
+
* .port("80")
|
|
1375
|
+
* .protocol("HTTP")
|
|
1376
|
+
* .defaultActions(ListenerDefaultAction.builder()
|
|
1377
|
+
* .type("fixed-response")
|
|
1378
|
+
* .fixedResponse(ListenerDefaultActionFixedResponse.builder()
|
|
1379
|
+
* .contentType("text/plain")
|
|
1380
|
+
* .messageBody("Fixed response content")
|
|
1381
|
+
* .statusCode("200")
|
|
1382
|
+
* .build())
|
|
1383
|
+
* .build())
|
|
1384
|
+
* .build());
|
|
1385
|
+
*
|
|
1386
|
+
* }
|
|
1387
|
+
* }
|
|
1388
|
+
* ```
|
|
1389
|
+
* ```yaml
|
|
1390
|
+
* resources:
|
|
1391
|
+
* frontEndLoadBalancer:
|
|
1392
|
+
* type: aws:lb:LoadBalancer
|
|
1393
|
+
* frontEndListener:
|
|
1394
|
+
* type: aws:lb:Listener
|
|
1395
|
+
* properties:
|
|
1396
|
+
* loadBalancerArn: ${frontEndLoadBalancer.arn}
|
|
1397
|
+
* port: 80
|
|
1398
|
+
* protocol: HTTP
|
|
1399
|
+
* defaultActions:
|
|
1400
|
+
* - type: fixed-response
|
|
1401
|
+
* fixedResponse:
|
|
1402
|
+
* contentType: text/plain
|
|
1403
|
+
* messageBody: Fixed response content
|
|
1404
|
+
* statusCode: 200
|
|
1405
|
+
* ```
|
|
1212
1406
|
* {{% /example %}}
|
|
1213
1407
|
* {{% example %}}
|
|
1214
1408
|
* ### Authenticate-cognito Action
|
|
@@ -1229,7 +1423,7 @@ export declare namespace lb {
|
|
|
1229
1423
|
* // ...
|
|
1230
1424
|
* const frontEndListener = new aws.lb.Listener("frontEndListener", {
|
|
1231
1425
|
* loadBalancerArn: frontEndLoadBalancer.arn,
|
|
1232
|
-
* port:
|
|
1426
|
+
* port: 80,
|
|
1233
1427
|
* protocol: "HTTP",
|
|
1234
1428
|
* defaultActions: [
|
|
1235
1429
|
* {
|
|
@@ -1393,6 +1587,79 @@ export declare namespace lb {
|
|
|
1393
1587
|
* })
|
|
1394
1588
|
* }
|
|
1395
1589
|
* ```
|
|
1590
|
+
* ```java
|
|
1591
|
+
* package generated_program;
|
|
1592
|
+
*
|
|
1593
|
+
* import java.util.*;
|
|
1594
|
+
* import java.io.*;
|
|
1595
|
+
* import java.nio.*;
|
|
1596
|
+
* import com.pulumi.*;
|
|
1597
|
+
*
|
|
1598
|
+
* public class App {
|
|
1599
|
+
* public static void main(String[] args) {
|
|
1600
|
+
* Pulumi.run(App::stack);
|
|
1601
|
+
* }
|
|
1602
|
+
*
|
|
1603
|
+
* public static void stack(Context ctx) {
|
|
1604
|
+
* var frontEndLoadBalancer = new LoadBalancer("frontEndLoadBalancer");
|
|
1605
|
+
*
|
|
1606
|
+
* var frontEndTargetGroup = new TargetGroup("frontEndTargetGroup");
|
|
1607
|
+
*
|
|
1608
|
+
* var pool = new UserPool("pool");
|
|
1609
|
+
*
|
|
1610
|
+
* var client = new UserPoolClient("client");
|
|
1611
|
+
*
|
|
1612
|
+
* var domain = new UserPoolDomain("domain");
|
|
1613
|
+
*
|
|
1614
|
+
* var frontEndListener = new Listener("frontEndListener", ListenerArgs.builder()
|
|
1615
|
+
* .loadBalancerArn(frontEndLoadBalancer.getArn())
|
|
1616
|
+
* .port("80")
|
|
1617
|
+
* .protocol("HTTP")
|
|
1618
|
+
* .defaultActions(
|
|
1619
|
+
* ListenerDefaultAction.builder()
|
|
1620
|
+
* .type("authenticate-cognito")
|
|
1621
|
+
* .authenticateCognito(ListenerDefaultActionAuthenticateCognito.builder()
|
|
1622
|
+
* .userPoolArn(pool.getArn())
|
|
1623
|
+
* .userPoolClientId(client.getId())
|
|
1624
|
+
* .userPoolDomain(domain.getDomain())
|
|
1625
|
+
* .build())
|
|
1626
|
+
* .build(),
|
|
1627
|
+
* ListenerDefaultAction.builder()
|
|
1628
|
+
* .type("forward")
|
|
1629
|
+
* .targetGroupArn(frontEndTargetGroup.getArn())
|
|
1630
|
+
* .build())
|
|
1631
|
+
* .build());
|
|
1632
|
+
*
|
|
1633
|
+
* }
|
|
1634
|
+
* }
|
|
1635
|
+
* ```
|
|
1636
|
+
* ```yaml
|
|
1637
|
+
* resources:
|
|
1638
|
+
* frontEndLoadBalancer:
|
|
1639
|
+
* type: aws:lb:LoadBalancer
|
|
1640
|
+
* frontEndTargetGroup:
|
|
1641
|
+
* type: aws:lb:TargetGroup
|
|
1642
|
+
* pool:
|
|
1643
|
+
* type: aws:cognito:UserPool
|
|
1644
|
+
* client:
|
|
1645
|
+
* type: aws:cognito:UserPoolClient
|
|
1646
|
+
* domain:
|
|
1647
|
+
* type: aws:cognito:UserPoolDomain
|
|
1648
|
+
* frontEndListener:
|
|
1649
|
+
* type: aws:lb:Listener
|
|
1650
|
+
* properties:
|
|
1651
|
+
* loadBalancerArn: ${frontEndLoadBalancer.arn}
|
|
1652
|
+
* port: 80
|
|
1653
|
+
* protocol: HTTP
|
|
1654
|
+
* defaultActions:
|
|
1655
|
+
* - type: authenticate-cognito
|
|
1656
|
+
* authenticateCognito:
|
|
1657
|
+
* userPoolArn: ${pool.arn}
|
|
1658
|
+
* userPoolClientId: ${client.id}
|
|
1659
|
+
* userPoolDomain: ${domain.domain}
|
|
1660
|
+
* - type: forward
|
|
1661
|
+
* targetGroupArn: ${frontEndTargetGroup.arn}
|
|
1662
|
+
* ```
|
|
1396
1663
|
* {{% /example %}}
|
|
1397
1664
|
* {{% example %}}
|
|
1398
1665
|
* ### Authenticate-OIDC Action
|
|
@@ -1407,7 +1674,7 @@ export declare namespace lb {
|
|
|
1407
1674
|
* // ...
|
|
1408
1675
|
* const frontEndListener = new aws.lb.Listener("frontEndListener", {
|
|
1409
1676
|
* loadBalancerArn: frontEndLoadBalancer.arn,
|
|
1410
|
-
* port:
|
|
1677
|
+
* port: 80,
|
|
1411
1678
|
* protocol: "HTTP",
|
|
1412
1679
|
* defaultActions: [
|
|
1413
1680
|
* {
|
|
@@ -1552,6 +1819,73 @@ export declare namespace lb {
|
|
|
1552
1819
|
* })
|
|
1553
1820
|
* }
|
|
1554
1821
|
* ```
|
|
1822
|
+
* ```java
|
|
1823
|
+
* package generated_program;
|
|
1824
|
+
*
|
|
1825
|
+
* import java.util.*;
|
|
1826
|
+
* import java.io.*;
|
|
1827
|
+
* import java.nio.*;
|
|
1828
|
+
* import com.pulumi.*;
|
|
1829
|
+
*
|
|
1830
|
+
* public class App {
|
|
1831
|
+
* public static void main(String[] args) {
|
|
1832
|
+
* Pulumi.run(App::stack);
|
|
1833
|
+
* }
|
|
1834
|
+
*
|
|
1835
|
+
* public static void stack(Context ctx) {
|
|
1836
|
+
* var frontEndLoadBalancer = new LoadBalancer("frontEndLoadBalancer");
|
|
1837
|
+
*
|
|
1838
|
+
* var frontEndTargetGroup = new TargetGroup("frontEndTargetGroup");
|
|
1839
|
+
*
|
|
1840
|
+
* var frontEndListener = new Listener("frontEndListener", ListenerArgs.builder()
|
|
1841
|
+
* .loadBalancerArn(frontEndLoadBalancer.getArn())
|
|
1842
|
+
* .port("80")
|
|
1843
|
+
* .protocol("HTTP")
|
|
1844
|
+
* .defaultActions(
|
|
1845
|
+
* ListenerDefaultAction.builder()
|
|
1846
|
+
* .type("authenticate-oidc")
|
|
1847
|
+
* .authenticateOidc(ListenerDefaultActionAuthenticateOidc.builder()
|
|
1848
|
+
* .authorizationEndpoint("https://example.com/authorization_endpoint")
|
|
1849
|
+
* .clientId("client_id")
|
|
1850
|
+
* .clientSecret("client_secret")
|
|
1851
|
+
* .issuer("https://example.com")
|
|
1852
|
+
* .tokenEndpoint("https://example.com/token_endpoint")
|
|
1853
|
+
* .userInfoEndpoint("https://example.com/user_info_endpoint")
|
|
1854
|
+
* .build())
|
|
1855
|
+
* .build(),
|
|
1856
|
+
* ListenerDefaultAction.builder()
|
|
1857
|
+
* .type("forward")
|
|
1858
|
+
* .targetGroupArn(frontEndTargetGroup.getArn())
|
|
1859
|
+
* .build())
|
|
1860
|
+
* .build());
|
|
1861
|
+
*
|
|
1862
|
+
* }
|
|
1863
|
+
* }
|
|
1864
|
+
* ```
|
|
1865
|
+
* ```yaml
|
|
1866
|
+
* resources:
|
|
1867
|
+
* frontEndLoadBalancer:
|
|
1868
|
+
* type: aws:lb:LoadBalancer
|
|
1869
|
+
* frontEndTargetGroup:
|
|
1870
|
+
* type: aws:lb:TargetGroup
|
|
1871
|
+
* frontEndListener:
|
|
1872
|
+
* type: aws:lb:Listener
|
|
1873
|
+
* properties:
|
|
1874
|
+
* loadBalancerArn: ${frontEndLoadBalancer.arn}
|
|
1875
|
+
* port: 80
|
|
1876
|
+
* protocol: HTTP
|
|
1877
|
+
* defaultActions:
|
|
1878
|
+
* - type: authenticate-oidc
|
|
1879
|
+
* authenticateOidc:
|
|
1880
|
+
* authorizationEndpoint: https://example.com/authorization_endpoint
|
|
1881
|
+
* clientId: client_id
|
|
1882
|
+
* clientSecret: client_secret
|
|
1883
|
+
* issuer: https://example.com
|
|
1884
|
+
* tokenEndpoint: https://example.com/token_endpoint
|
|
1885
|
+
* userInfoEndpoint: https://example.com/user_info_endpoint
|
|
1886
|
+
* - type: forward
|
|
1887
|
+
* targetGroupArn: ${frontEndTargetGroup.arn}
|
|
1888
|
+
* ```
|
|
1555
1889
|
* {{% /example %}}
|
|
1556
1890
|
* {{% example %}}
|
|
1557
1891
|
* ### Gateway Load Balancer Listener
|
|
@@ -1571,7 +1905,7 @@ export declare namespace lb {
|
|
|
1571
1905
|
* protocol: "GENEVE",
|
|
1572
1906
|
* vpcId: aws_vpc.example.id,
|
|
1573
1907
|
* healthCheck: {
|
|
1574
|
-
* port: 80,
|
|
1908
|
+
* port: "80",
|
|
1575
1909
|
* protocol: "HTTP",
|
|
1576
1910
|
* },
|
|
1577
1911
|
* });
|
|
@@ -1702,6 +2036,73 @@ export declare namespace lb {
|
|
|
1702
2036
|
* })
|
|
1703
2037
|
* }
|
|
1704
2038
|
* ```
|
|
2039
|
+
* ```java
|
|
2040
|
+
* package generated_program;
|
|
2041
|
+
*
|
|
2042
|
+
* import java.util.*;
|
|
2043
|
+
* import java.io.*;
|
|
2044
|
+
* import java.nio.*;
|
|
2045
|
+
* import com.pulumi.*;
|
|
2046
|
+
*
|
|
2047
|
+
* public class App {
|
|
2048
|
+
* public static void main(String[] args) {
|
|
2049
|
+
* Pulumi.run(App::stack);
|
|
2050
|
+
* }
|
|
2051
|
+
*
|
|
2052
|
+
* public static void stack(Context ctx) {
|
|
2053
|
+
* var exampleLoadBalancer = new LoadBalancer("exampleLoadBalancer", LoadBalancerArgs.builder()
|
|
2054
|
+
* .loadBalancerType("gateway")
|
|
2055
|
+
* .subnetMappings(LoadBalancerSubnetMapping.builder()
|
|
2056
|
+
* .subnetId(aws_subnet.getExample().getId())
|
|
2057
|
+
* .build())
|
|
2058
|
+
* .build());
|
|
2059
|
+
*
|
|
2060
|
+
* var exampleTargetGroup = new TargetGroup("exampleTargetGroup", TargetGroupArgs.builder()
|
|
2061
|
+
* .port(6081)
|
|
2062
|
+
* .protocol("GENEVE")
|
|
2063
|
+
* .vpcId(aws_vpc.getExample().getId())
|
|
2064
|
+
* .healthCheck(TargetGroupHealthCheck.builder()
|
|
2065
|
+
* .port(80)
|
|
2066
|
+
* .protocol("HTTP")
|
|
2067
|
+
* .build())
|
|
2068
|
+
* .build());
|
|
2069
|
+
*
|
|
2070
|
+
* var exampleListener = new Listener("exampleListener", ListenerArgs.builder()
|
|
2071
|
+
* .loadBalancerArn(exampleLoadBalancer.getId())
|
|
2072
|
+
* .defaultActions(ListenerDefaultAction.builder()
|
|
2073
|
+
* .targetGroupArn(exampleTargetGroup.getId())
|
|
2074
|
+
* .type("forward")
|
|
2075
|
+
* .build())
|
|
2076
|
+
* .build());
|
|
2077
|
+
*
|
|
2078
|
+
* }
|
|
2079
|
+
* }
|
|
2080
|
+
* ```
|
|
2081
|
+
* ```yaml
|
|
2082
|
+
* resources:
|
|
2083
|
+
* exampleLoadBalancer:
|
|
2084
|
+
* type: aws:lb:LoadBalancer
|
|
2085
|
+
* properties:
|
|
2086
|
+
* loadBalancerType: gateway
|
|
2087
|
+
* subnetMappings:
|
|
2088
|
+
* - subnetId: ${aws_subnet.example.id}
|
|
2089
|
+
* exampleTargetGroup:
|
|
2090
|
+
* type: aws:lb:TargetGroup
|
|
2091
|
+
* properties:
|
|
2092
|
+
* port: 6081
|
|
2093
|
+
* protocol: GENEVE
|
|
2094
|
+
* vpcId: ${aws_vpc.example.id}
|
|
2095
|
+
* healthCheck:
|
|
2096
|
+
* port: 80
|
|
2097
|
+
* protocol: HTTP
|
|
2098
|
+
* exampleListener:
|
|
2099
|
+
* type: aws:lb:Listener
|
|
2100
|
+
* properties:
|
|
2101
|
+
* loadBalancerArn: ${exampleLoadBalancer.id}
|
|
2102
|
+
* defaultActions:
|
|
2103
|
+
* - targetGroupArn: ${exampleTargetGroup.id}
|
|
2104
|
+
* type: forward
|
|
2105
|
+
* ```
|
|
1705
2106
|
* {{% /example %}}
|
|
1706
2107
|
* {{% /examples %}}
|
|
1707
2108
|
*
|
|
@@ -1829,6 +2230,46 @@ export declare namespace lb {
|
|
|
1829
2230
|
* })
|
|
1830
2231
|
* }
|
|
1831
2232
|
* ```
|
|
2233
|
+
* ```java
|
|
2234
|
+
* package generated_program;
|
|
2235
|
+
*
|
|
2236
|
+
* import java.util.*;
|
|
2237
|
+
* import java.io.*;
|
|
2238
|
+
* import java.nio.*;
|
|
2239
|
+
* import com.pulumi.*;
|
|
2240
|
+
*
|
|
2241
|
+
* public class App {
|
|
2242
|
+
* public static void main(String[] args) {
|
|
2243
|
+
* Pulumi.run(App::stack);
|
|
2244
|
+
* }
|
|
2245
|
+
*
|
|
2246
|
+
* public static void stack(Context ctx) {
|
|
2247
|
+
* var main = new Vpc("main", VpcArgs.builder()
|
|
2248
|
+
* .cidrBlock("10.0.0.0/16")
|
|
2249
|
+
* .build());
|
|
2250
|
+
*
|
|
2251
|
+
* var test = new TargetGroup("test", TargetGroupArgs.builder()
|
|
2252
|
+
* .port(80)
|
|
2253
|
+
* .protocol("HTTP")
|
|
2254
|
+
* .vpcId(main.getId())
|
|
2255
|
+
* .build());
|
|
2256
|
+
*
|
|
2257
|
+
* }
|
|
2258
|
+
* }
|
|
2259
|
+
* ```
|
|
2260
|
+
* ```yaml
|
|
2261
|
+
* resources:
|
|
2262
|
+
* test:
|
|
2263
|
+
* type: aws:lb:TargetGroup
|
|
2264
|
+
* properties:
|
|
2265
|
+
* port: 80
|
|
2266
|
+
* protocol: HTTP
|
|
2267
|
+
* vpcId: ${main.id}
|
|
2268
|
+
* main:
|
|
2269
|
+
* type: aws:ec2:Vpc
|
|
2270
|
+
* properties:
|
|
2271
|
+
* cidrBlock: 10.0.0.0/16
|
|
2272
|
+
* ```
|
|
1832
2273
|
* {{% /example %}}
|
|
1833
2274
|
* {{% example %}}
|
|
1834
2275
|
* ### IP Target Group
|
|
@@ -1909,6 +2350,48 @@ export declare namespace lb {
|
|
|
1909
2350
|
* })
|
|
1910
2351
|
* }
|
|
1911
2352
|
* ```
|
|
2353
|
+
* ```java
|
|
2354
|
+
* package generated_program;
|
|
2355
|
+
*
|
|
2356
|
+
* import java.util.*;
|
|
2357
|
+
* import java.io.*;
|
|
2358
|
+
* import java.nio.*;
|
|
2359
|
+
* import com.pulumi.*;
|
|
2360
|
+
*
|
|
2361
|
+
* public class App {
|
|
2362
|
+
* public static void main(String[] args) {
|
|
2363
|
+
* Pulumi.run(App::stack);
|
|
2364
|
+
* }
|
|
2365
|
+
*
|
|
2366
|
+
* public static void stack(Context ctx) {
|
|
2367
|
+
* var main = new Vpc("main", VpcArgs.builder()
|
|
2368
|
+
* .cidrBlock("10.0.0.0/16")
|
|
2369
|
+
* .build());
|
|
2370
|
+
*
|
|
2371
|
+
* var ip_example = new TargetGroup("ip-example", TargetGroupArgs.builder()
|
|
2372
|
+
* .port(80)
|
|
2373
|
+
* .protocol("HTTP")
|
|
2374
|
+
* .targetType("ip")
|
|
2375
|
+
* .vpcId(main.getId())
|
|
2376
|
+
* .build());
|
|
2377
|
+
*
|
|
2378
|
+
* }
|
|
2379
|
+
* }
|
|
2380
|
+
* ```
|
|
2381
|
+
* ```yaml
|
|
2382
|
+
* resources:
|
|
2383
|
+
* ip-example:
|
|
2384
|
+
* type: aws:lb:TargetGroup
|
|
2385
|
+
* properties:
|
|
2386
|
+
* port: 80
|
|
2387
|
+
* protocol: HTTP
|
|
2388
|
+
* targetType: ip
|
|
2389
|
+
* vpcId: ${main.id}
|
|
2390
|
+
* main:
|
|
2391
|
+
* type: aws:ec2:Vpc
|
|
2392
|
+
* properties:
|
|
2393
|
+
* cidrBlock: 10.0.0.0/16
|
|
2394
|
+
* ```
|
|
1912
2395
|
* {{% /example %}}
|
|
1913
2396
|
* {{% example %}}
|
|
1914
2397
|
* ### Lambda Target Group
|
|
@@ -1963,6 +2446,34 @@ export declare namespace lb {
|
|
|
1963
2446
|
* })
|
|
1964
2447
|
* }
|
|
1965
2448
|
* ```
|
|
2449
|
+
* ```java
|
|
2450
|
+
* package generated_program;
|
|
2451
|
+
*
|
|
2452
|
+
* import java.util.*;
|
|
2453
|
+
* import java.io.*;
|
|
2454
|
+
* import java.nio.*;
|
|
2455
|
+
* import com.pulumi.*;
|
|
2456
|
+
*
|
|
2457
|
+
* public class App {
|
|
2458
|
+
* public static void main(String[] args) {
|
|
2459
|
+
* Pulumi.run(App::stack);
|
|
2460
|
+
* }
|
|
2461
|
+
*
|
|
2462
|
+
* public static void stack(Context ctx) {
|
|
2463
|
+
* var lambda_example = new TargetGroup("lambda-example", TargetGroupArgs.builder()
|
|
2464
|
+
* .targetType("lambda")
|
|
2465
|
+
* .build());
|
|
2466
|
+
*
|
|
2467
|
+
* }
|
|
2468
|
+
* }
|
|
2469
|
+
* ```
|
|
2470
|
+
* ```yaml
|
|
2471
|
+
* resources:
|
|
2472
|
+
* lambda-example:
|
|
2473
|
+
* type: aws:lb:TargetGroup
|
|
2474
|
+
* properties:
|
|
2475
|
+
* targetType: lambda
|
|
2476
|
+
* ```
|
|
1966
2477
|
* {{% /example %}}
|
|
1967
2478
|
* {{% example %}}
|
|
1968
2479
|
* ### ALB Target Group
|
|
@@ -2030,6 +2541,40 @@ export declare namespace lb {
|
|
|
2030
2541
|
* })
|
|
2031
2542
|
* }
|
|
2032
2543
|
* ```
|
|
2544
|
+
* ```java
|
|
2545
|
+
* package generated_program;
|
|
2546
|
+
*
|
|
2547
|
+
* import java.util.*;
|
|
2548
|
+
* import java.io.*;
|
|
2549
|
+
* import java.nio.*;
|
|
2550
|
+
* import com.pulumi.*;
|
|
2551
|
+
*
|
|
2552
|
+
* public class App {
|
|
2553
|
+
* public static void main(String[] args) {
|
|
2554
|
+
* Pulumi.run(App::stack);
|
|
2555
|
+
* }
|
|
2556
|
+
*
|
|
2557
|
+
* public static void stack(Context ctx) {
|
|
2558
|
+
* var lambda_example = new TargetGroup("lambda-example", TargetGroupArgs.builder()
|
|
2559
|
+
* .targetType("alb")
|
|
2560
|
+
* .port(80)
|
|
2561
|
+
* .protocol("TCP")
|
|
2562
|
+
* .vpcId(aws_vpc.getMain().getId())
|
|
2563
|
+
* .build());
|
|
2564
|
+
*
|
|
2565
|
+
* }
|
|
2566
|
+
* }
|
|
2567
|
+
* ```
|
|
2568
|
+
* ```yaml
|
|
2569
|
+
* resources:
|
|
2570
|
+
* lambda-example:
|
|
2571
|
+
* type: aws:lb:TargetGroup
|
|
2572
|
+
* properties:
|
|
2573
|
+
* targetType: alb
|
|
2574
|
+
* port: 80
|
|
2575
|
+
* protocol: TCP
|
|
2576
|
+
* vpcId: ${aws_vpc.main.id}
|
|
2577
|
+
* ```
|
|
2033
2578
|
* {{% /example %}}
|
|
2034
2579
|
* {{% /examples %}}
|
|
2035
2580
|
*
|