@aws-mdaa/devops 1.3.0 → 1.5.0
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/SCHEMA.md +7107 -338
- package/lib/config-schema.json +2684 -139
- package/lib/devops.js +2 -16
- package/package.json +21 -22
package/lib/config-schema.json
CHANGED
|
@@ -2,6 +2,208 @@
|
|
|
2
2
|
"$schema": "http://json-schema.org/draft-07/schema#",
|
|
3
3
|
"additionalProperties": false,
|
|
4
4
|
"definitions": {
|
|
5
|
+
"AdditionalBlueprintAccount": {
|
|
6
|
+
"additionalProperties": false,
|
|
7
|
+
"properties": {
|
|
8
|
+
"account": {
|
|
9
|
+
"type": "string"
|
|
10
|
+
},
|
|
11
|
+
"authorizedDomainUnits": {
|
|
12
|
+
"items": {
|
|
13
|
+
"type": "string"
|
|
14
|
+
},
|
|
15
|
+
"type": "array"
|
|
16
|
+
},
|
|
17
|
+
"enabledRegions": {
|
|
18
|
+
"items": {
|
|
19
|
+
"type": "string"
|
|
20
|
+
},
|
|
21
|
+
"type": "array"
|
|
22
|
+
},
|
|
23
|
+
"parameters": {
|
|
24
|
+
"additionalProperties": {
|
|
25
|
+
"$ref": "#/definitions/MdaaSageMakerBluePrintParameterConfig"
|
|
26
|
+
},
|
|
27
|
+
"type": "object"
|
|
28
|
+
},
|
|
29
|
+
"provisioningRole": {
|
|
30
|
+
"$ref": "#/definitions/MdaaRoleRef"
|
|
31
|
+
}
|
|
32
|
+
},
|
|
33
|
+
"required": [
|
|
34
|
+
"account",
|
|
35
|
+
"provisioningRole"
|
|
36
|
+
],
|
|
37
|
+
"type": "object"
|
|
38
|
+
},
|
|
39
|
+
"Architecture": {
|
|
40
|
+
"additionalProperties": false,
|
|
41
|
+
"description": "Architectures supported by AWS Lambda",
|
|
42
|
+
"properties": {
|
|
43
|
+
"dockerPlatform": {
|
|
44
|
+
"description": "The platform to use for this architecture when building with Docker.",
|
|
45
|
+
"type": "string"
|
|
46
|
+
},
|
|
47
|
+
"name": {
|
|
48
|
+
"description": "The name of the architecture as recognized by the AWS Lambda service APIs.",
|
|
49
|
+
"type": "string"
|
|
50
|
+
}
|
|
51
|
+
},
|
|
52
|
+
"required": [
|
|
53
|
+
"dockerPlatform",
|
|
54
|
+
"name"
|
|
55
|
+
],
|
|
56
|
+
"type": "object"
|
|
57
|
+
},
|
|
58
|
+
"CfnAutoScalingReplacingUpdate": {
|
|
59
|
+
"additionalProperties": false,
|
|
60
|
+
"description": "Specifies whether an Auto Scaling group and the instances it contains are replaced during an update. During replacement,\nAWS CloudFormation retains the old group until it finishes creating the new one. If the update fails, AWS CloudFormation\ncan roll back to the old Auto Scaling group and delete the new Auto Scaling group.\n\nWhile AWS CloudFormation creates the new group, it doesn't detach or attach any instances. After successfully creating\nthe new Auto Scaling group, AWS CloudFormation deletes the old Auto Scaling group during the cleanup process.\n\nWhen you set the WillReplace parameter, remember to specify a matching CreationPolicy. If the minimum number of\ninstances (specified by the MinSuccessfulInstancesPercent property) don't signal success within the Timeout period\n(specified in the CreationPolicy policy), the replacement update fails and AWS CloudFormation rolls back to the old\nAuto Scaling group.",
|
|
61
|
+
"properties": {
|
|
62
|
+
"willReplace": {
|
|
63
|
+
"type": "boolean"
|
|
64
|
+
}
|
|
65
|
+
},
|
|
66
|
+
"type": "object"
|
|
67
|
+
},
|
|
68
|
+
"CfnAutoScalingRollingUpdate": {
|
|
69
|
+
"additionalProperties": false,
|
|
70
|
+
"description": "To specify how AWS CloudFormation handles rolling updates for an Auto Scaling group, use the AutoScalingRollingUpdate\npolicy. Rolling updates enable you to specify whether AWS CloudFormation updates instances that are in an Auto Scaling\ngroup in batches or all at once.",
|
|
71
|
+
"properties": {
|
|
72
|
+
"maxBatchSize": {
|
|
73
|
+
"description": "Specifies the maximum number of instances that AWS CloudFormation updates.",
|
|
74
|
+
"type": "number"
|
|
75
|
+
},
|
|
76
|
+
"minActiveInstancesPercent": {
|
|
77
|
+
"description": "Specifies the percentage of instances in an Auto Scaling group that must remain in service while AWS CloudFormation\nupdates old instances. You can specify a value from 0 to 100. AWS CloudFormation rounds to the nearest tenth of a percent.\nFor example, if you update five instances with a minimum active percentage of 50, three instances must remain in service.",
|
|
78
|
+
"type": "number"
|
|
79
|
+
},
|
|
80
|
+
"minInstancesInService": {
|
|
81
|
+
"description": "Specifies the minimum number of instances that must be in service within the Auto Scaling group while AWS\nCloudFormation updates old instances.",
|
|
82
|
+
"type": "number"
|
|
83
|
+
},
|
|
84
|
+
"minSuccessfulInstancesPercent": {
|
|
85
|
+
"description": "Specifies the percentage of instances in an Auto Scaling rolling update that must signal success for an update to succeed.\nYou can specify a value from 0 to 100. AWS CloudFormation rounds to the nearest tenth of a percent. For example, if you\nupdate five instances with a minimum successful percentage of 50, three instances must signal success.\n\nIf an instance doesn't send a signal within the time specified in the PauseTime property, AWS CloudFormation assumes\nthat the instance wasn't updated.\n\nIf you specify this property, you must also enable the WaitOnResourceSignals and PauseTime properties.",
|
|
86
|
+
"type": "number"
|
|
87
|
+
},
|
|
88
|
+
"pauseTime": {
|
|
89
|
+
"description": "The amount of time that AWS CloudFormation pauses after making a change to a batch of instances to give those instances\ntime to start software applications. For example, you might need to specify PauseTime when scaling up the number of\ninstances in an Auto Scaling group.\n\nIf you enable the WaitOnResourceSignals property, PauseTime is the amount of time that AWS CloudFormation should wait\nfor the Auto Scaling group to receive the required number of valid signals from added or replaced instances. If the\nPauseTime is exceeded before the Auto Scaling group receives the required number of signals, the update fails. For best\nresults, specify a time period that gives your applications sufficient time to get started. If the update needs to be\nrolled back, a short PauseTime can cause the rollback to fail.\n\nSpecify PauseTime in the ISO8601 duration format (in the format PT#H#M#S, where each # is the number of hours, minutes,\nand seconds, respectively). The maximum PauseTime is one hour (PT1H).",
|
|
90
|
+
"type": "string"
|
|
91
|
+
},
|
|
92
|
+
"suspendProcesses": {
|
|
93
|
+
"description": "Specifies the Auto Scaling processes to suspend during a stack update. Suspending processes prevents Auto Scaling from\ninterfering with a stack update. For example, you can suspend alarming so that Auto Scaling doesn't execute scaling\npolicies associated with an alarm. For valid values, see the ScalingProcesses.member.N parameter for the SuspendProcesses\naction in the Auto Scaling API Reference.",
|
|
94
|
+
"items": {
|
|
95
|
+
"type": "string"
|
|
96
|
+
},
|
|
97
|
+
"type": "array"
|
|
98
|
+
},
|
|
99
|
+
"waitOnResourceSignals": {
|
|
100
|
+
"description": "Specifies whether the Auto Scaling group waits on signals from new instances during an update. Use this property to\nensure that instances have completed installing and configuring applications before the Auto Scaling group update proceeds.\nAWS CloudFormation suspends the update of an Auto Scaling group after new EC2 instances are launched into the group.\nAWS CloudFormation must receive a signal from each new instance within the specified PauseTime before continuing the update.\nTo signal the Auto Scaling group, use the cfn-signal helper script or SignalResource API.\n\nTo have instances wait for an Elastic Load Balancing health check before they signal success, add a health-check\nverification by using the cfn-init helper script. For an example, see the verify_instance_health command in the Auto Scaling\nrolling updates sample template.",
|
|
101
|
+
"type": "boolean"
|
|
102
|
+
}
|
|
103
|
+
},
|
|
104
|
+
"type": "object"
|
|
105
|
+
},
|
|
106
|
+
"CfnAutoScalingScheduledAction": {
|
|
107
|
+
"additionalProperties": false,
|
|
108
|
+
"description": "With scheduled actions, the group size properties of an Auto Scaling group can change at any time. When you update a\nstack with an Auto Scaling group and scheduled action, AWS CloudFormation always sets the group size property values of\nyour Auto Scaling group to the values that are defined in the AWS::AutoScaling::AutoScalingGroup resource of your template,\neven if a scheduled action is in effect.\n\nIf you do not want AWS CloudFormation to change any of the group size property values when you have a scheduled action in\neffect, use the AutoScalingScheduledAction update policy to prevent AWS CloudFormation from changing the MinSize, MaxSize,\nor DesiredCapacity properties unless you have modified these values in your template.\\",
|
|
109
|
+
"properties": {
|
|
110
|
+
"ignoreUnmodifiedGroupSizeProperties": {
|
|
111
|
+
"type": "boolean"
|
|
112
|
+
}
|
|
113
|
+
},
|
|
114
|
+
"type": "object"
|
|
115
|
+
},
|
|
116
|
+
"CfnCodeDeployLambdaAliasUpdate": {
|
|
117
|
+
"additionalProperties": false,
|
|
118
|
+
"description": "To perform an AWS CodeDeploy deployment when the version changes on an AWS::Lambda::Alias resource,\nuse the CodeDeployLambdaAliasUpdate update policy.",
|
|
119
|
+
"properties": {
|
|
120
|
+
"afterAllowTrafficHook": {
|
|
121
|
+
"description": "The name of the Lambda function to run after traffic routing completes.",
|
|
122
|
+
"type": "string"
|
|
123
|
+
},
|
|
124
|
+
"applicationName": {
|
|
125
|
+
"description": "The name of the AWS CodeDeploy application.",
|
|
126
|
+
"type": "string"
|
|
127
|
+
},
|
|
128
|
+
"beforeAllowTrafficHook": {
|
|
129
|
+
"description": "The name of the Lambda function to run before traffic routing starts.",
|
|
130
|
+
"type": "string"
|
|
131
|
+
},
|
|
132
|
+
"deploymentGroupName": {
|
|
133
|
+
"description": "The name of the AWS CodeDeploy deployment group. This is where the traffic-shifting policy is set.",
|
|
134
|
+
"type": "string"
|
|
135
|
+
}
|
|
136
|
+
},
|
|
137
|
+
"required": [
|
|
138
|
+
"applicationName",
|
|
139
|
+
"deploymentGroupName"
|
|
140
|
+
],
|
|
141
|
+
"type": "object"
|
|
142
|
+
},
|
|
143
|
+
"CfnCondition": {
|
|
144
|
+
"additionalProperties": false,
|
|
145
|
+
"description": "Represents a CloudFormation condition, for resources which must be conditionally created and\nthe determination must be made at deploy time.",
|
|
146
|
+
"properties": {
|
|
147
|
+
"_logicalIdLocked": {
|
|
148
|
+
"description": "If the logicalId is locked then it can no longer be overridden.\nThis is needed for cases where the logicalId is consumed prior to synthesis\n(i.e. Stack.exportValue)."
|
|
149
|
+
},
|
|
150
|
+
"_logicalIdOverride": {
|
|
151
|
+
"description": "An explicit logical ID provided by `overrideLogicalId`."
|
|
152
|
+
},
|
|
153
|
+
"creationStack": {
|
|
154
|
+
"items": {
|
|
155
|
+
"type": "string"
|
|
156
|
+
},
|
|
157
|
+
"type": "array"
|
|
158
|
+
},
|
|
159
|
+
"expression": {
|
|
160
|
+
"$ref": "#/definitions/ICfnConditionExpression",
|
|
161
|
+
"description": "The condition statement."
|
|
162
|
+
},
|
|
163
|
+
"logicalId": {
|
|
164
|
+
"description": "The logical ID for this CloudFormation stack element. The logical ID of the element\nis calculated from the path of the resource node in the construct tree.\n\nTo override this value, use `overrideLogicalId(newLogicalId)`.",
|
|
165
|
+
"type": "string"
|
|
166
|
+
},
|
|
167
|
+
"node": {
|
|
168
|
+
"$ref": "#/definitions/Node",
|
|
169
|
+
"description": "The tree node."
|
|
170
|
+
},
|
|
171
|
+
"stack": {
|
|
172
|
+
"$ref": "#/definitions/Stack",
|
|
173
|
+
"description": "The stack in which this element is defined. CfnElements must be defined within a stack scope (directly or indirectly)."
|
|
174
|
+
},
|
|
175
|
+
"synthesizeLogicalId": {
|
|
176
|
+
"description": "Called during synthesize to render the logical ID of this element. If\n`overrideLogicalId` was it will be used, otherwise, we will allocate the\nlogical ID through the stack."
|
|
177
|
+
}
|
|
178
|
+
},
|
|
179
|
+
"required": [
|
|
180
|
+
"creationStack",
|
|
181
|
+
"logicalId",
|
|
182
|
+
"node",
|
|
183
|
+
"stack",
|
|
184
|
+
"synthesizeLogicalId"
|
|
185
|
+
],
|
|
186
|
+
"type": "object"
|
|
187
|
+
},
|
|
188
|
+
"CfnCreationPolicy": {
|
|
189
|
+
"additionalProperties": false,
|
|
190
|
+
"description": "Associate the CreationPolicy attribute with a resource to prevent its status from reaching create complete until\nAWS CloudFormation receives a specified number of success signals or the timeout period is exceeded. To signal a\nresource, you can use the cfn-signal helper script or SignalResource API. AWS CloudFormation publishes valid signals\nto the stack events so that you track the number of signals sent.\n\nThe creation policy is invoked only when AWS CloudFormation creates the associated resource. Currently, the only\nAWS CloudFormation resources that support creation policies are AWS::AutoScaling::AutoScalingGroup, AWS::EC2::Instance,\nAWS::CloudFormation::WaitCondition and AWS::AppStream::Fleet.\n\nUse the CreationPolicy attribute when you want to wait on resource configuration actions before stack creation proceeds.\nFor example, if you install and configure software applications on an EC2 instance, you might want those applications to\nbe running before proceeding. In such cases, you can add a CreationPolicy attribute to the instance, and then send a success\nsignal to the instance after the applications are installed and configured. For a detailed example, see Deploying Applications\non Amazon EC2 with AWS CloudFormation.",
|
|
191
|
+
"properties": {
|
|
192
|
+
"autoScalingCreationPolicy": {
|
|
193
|
+
"$ref": "#/definitions/CfnResourceAutoScalingCreationPolicy",
|
|
194
|
+
"description": "For an Auto Scaling group replacement update, specifies how many instances must signal success for the\nupdate to succeed."
|
|
195
|
+
},
|
|
196
|
+
"resourceSignal": {
|
|
197
|
+
"$ref": "#/definitions/CfnResourceSignal",
|
|
198
|
+
"description": "When AWS CloudFormation creates the associated resource, configures the number of required success signals and\nthe length of time that AWS CloudFormation waits for those signals."
|
|
199
|
+
},
|
|
200
|
+
"startFleet": {
|
|
201
|
+
"description": "For an AppStream Fleet creation, specifies that the fleet is started after creation.",
|
|
202
|
+
"type": "boolean"
|
|
203
|
+
}
|
|
204
|
+
},
|
|
205
|
+
"type": "object"
|
|
206
|
+
},
|
|
5
207
|
"CfnParameterProps": {
|
|
6
208
|
"additionalProperties": false,
|
|
7
209
|
"properties": {
|
|
@@ -65,241 +267,2348 @@
|
|
|
65
267
|
},
|
|
66
268
|
"type": "object"
|
|
67
269
|
},
|
|
68
|
-
"
|
|
270
|
+
"CfnResource": {
|
|
69
271
|
"additionalProperties": false,
|
|
70
|
-
"description": "
|
|
272
|
+
"description": "Represents a CloudFormation resource.",
|
|
71
273
|
"properties": {
|
|
72
|
-
"
|
|
73
|
-
"description": "
|
|
274
|
+
"_cfnProperties": {
|
|
275
|
+
"description": "AWS CloudFormation resource properties.\n\nThis object is returned via cfnProperties"
|
|
276
|
+
},
|
|
277
|
+
"_logicalIdLocked": {
|
|
278
|
+
"description": "If the logicalId is locked then it can no longer be overridden.\nThis is needed for cases where the logicalId is consumed prior to synthesis\n(i.e. Stack.exportValue)."
|
|
279
|
+
},
|
|
280
|
+
"_logicalIdOverride": {
|
|
281
|
+
"description": "An explicit logical ID provided by `overrideLogicalId`."
|
|
282
|
+
},
|
|
283
|
+
"cfnOptions": {
|
|
284
|
+
"$ref": "#/definitions/ICfnResourceOptions",
|
|
285
|
+
"description": "Options for this resource, such as condition, update policy etc."
|
|
286
|
+
},
|
|
287
|
+
"cfnProperties": {
|
|
288
|
+
"additionalProperties": {},
|
|
289
|
+
"type": "object"
|
|
290
|
+
},
|
|
291
|
+
"cfnResourceType": {
|
|
292
|
+
"description": "AWS resource type.",
|
|
74
293
|
"type": "string"
|
|
75
294
|
},
|
|
76
|
-
"
|
|
77
|
-
"description": "Q-ENHANCED-PROPERTY\nArray of specific CDK Nag rule suppressions with rule IDs and mandatory justifications for audit compliance. Each suppression must include the rule identifier and business justification for the security exception.\n\nUse cases: Multiple rule suppressions per resource; Documented security exceptions; Audit trail maintenance\n\nAWS: CDK Nag rule ID suppression with justification tracking for compliance auditing\n\nValidation: Each suppression must have valid CDK Nag rule ID and non-empty reason string\n *",
|
|
295
|
+
"creationStack": {
|
|
78
296
|
"items": {
|
|
79
|
-
"
|
|
80
|
-
|
|
81
|
-
|
|
82
|
-
|
|
83
|
-
|
|
84
|
-
|
|
85
|
-
|
|
86
|
-
|
|
87
|
-
|
|
88
|
-
|
|
89
|
-
|
|
90
|
-
|
|
91
|
-
|
|
92
|
-
|
|
297
|
+
"type": "string"
|
|
298
|
+
},
|
|
299
|
+
"type": "array"
|
|
300
|
+
},
|
|
301
|
+
"dependsOn": {
|
|
302
|
+
"description": "Logical IDs of dependencies.\n\nIs filled during prepare()."
|
|
303
|
+
},
|
|
304
|
+
"logicalId": {
|
|
305
|
+
"description": "The logical ID for this CloudFormation stack element. The logical ID of the element\nis calculated from the path of the resource node in the construct tree.\n\nTo override this value, use `overrideLogicalId(newLogicalId)`.",
|
|
306
|
+
"type": "string"
|
|
307
|
+
},
|
|
308
|
+
"node": {
|
|
309
|
+
"$ref": "#/definitions/Node",
|
|
310
|
+
"description": "The tree node."
|
|
311
|
+
},
|
|
312
|
+
"rawOverrides": {
|
|
313
|
+
"description": "An object to be merged on top of the entire resource definition."
|
|
314
|
+
},
|
|
315
|
+
"ref": {
|
|
316
|
+
"description": "Return a string that will be resolved to a CloudFormation `{ Ref }` for this element.\n\nIf, by any chance, the intrinsic reference of a resource is not a string, you could\ncoerce it to an IResolvable through `Lazy.any({ produce: resource.ref })`.",
|
|
317
|
+
"type": "string"
|
|
318
|
+
},
|
|
319
|
+
"stack": {
|
|
320
|
+
"$ref": "#/definitions/Stack",
|
|
321
|
+
"description": "The stack in which this element is defined. CfnElements must be defined within a stack scope (directly or indirectly)."
|
|
322
|
+
},
|
|
323
|
+
"synthesizeLogicalId": {
|
|
324
|
+
"description": "Called during synthesize to render the logical ID of this element. If\n`overrideLogicalId` was it will be used, otherwise, we will allocate the\nlogical ID through the stack."
|
|
325
|
+
},
|
|
326
|
+
"updatedProperites": {
|
|
327
|
+
"additionalProperties": {},
|
|
328
|
+
"description": "Deprecated",
|
|
329
|
+
"type": "object"
|
|
330
|
+
},
|
|
331
|
+
"updatedProperties": {
|
|
332
|
+
"additionalProperties": {},
|
|
333
|
+
"description": "Return properties modified after initiation\n\nResources that expose mutable properties should override this function to\ncollect and return the properties object for this resource.",
|
|
334
|
+
"type": "object"
|
|
335
|
+
}
|
|
336
|
+
},
|
|
337
|
+
"required": [
|
|
338
|
+
"_cfnProperties",
|
|
339
|
+
"cfnOptions",
|
|
340
|
+
"cfnProperties",
|
|
341
|
+
"cfnResourceType",
|
|
342
|
+
"creationStack",
|
|
343
|
+
"dependsOn",
|
|
344
|
+
"logicalId",
|
|
345
|
+
"node",
|
|
346
|
+
"rawOverrides",
|
|
347
|
+
"ref",
|
|
348
|
+
"stack",
|
|
349
|
+
"synthesizeLogicalId",
|
|
350
|
+
"updatedProperites",
|
|
351
|
+
"updatedProperties"
|
|
352
|
+
],
|
|
353
|
+
"type": "object"
|
|
354
|
+
},
|
|
355
|
+
"CfnResourceAutoScalingCreationPolicy": {
|
|
356
|
+
"additionalProperties": false,
|
|
357
|
+
"description": "For an Auto Scaling group replacement update, specifies how many instances must signal success for the\nupdate to succeed.",
|
|
358
|
+
"properties": {
|
|
359
|
+
"minSuccessfulInstancesPercent": {
|
|
360
|
+
"description": "Specifies the percentage of instances in an Auto Scaling replacement update that must signal success for the\nupdate to succeed. You can specify a value from 0 to 100. AWS CloudFormation rounds to the nearest tenth of a percent.\nFor example, if you update five instances with a minimum successful percentage of 50, three instances must signal success.\nIf an instance doesn't send a signal within the time specified by the Timeout property, AWS CloudFormation assumes that the\ninstance wasn't created.",
|
|
361
|
+
"type": "number"
|
|
362
|
+
}
|
|
363
|
+
},
|
|
364
|
+
"type": "object"
|
|
365
|
+
},
|
|
366
|
+
"CfnResourceSignal": {
|
|
367
|
+
"additionalProperties": false,
|
|
368
|
+
"description": "When AWS CloudFormation creates the associated resource, configures the number of required success signals and\nthe length of time that AWS CloudFormation waits for those signals.",
|
|
369
|
+
"properties": {
|
|
370
|
+
"count": {
|
|
371
|
+
"description": "The number of success signals AWS CloudFormation must receive before it sets the resource status as CREATE_COMPLETE.\nIf the resource receives a failure signal or doesn't receive the specified number of signals before the timeout period\nexpires, the resource creation fails and AWS CloudFormation rolls the stack back.",
|
|
372
|
+
"type": "number"
|
|
373
|
+
},
|
|
374
|
+
"timeout": {
|
|
375
|
+
"description": "The length of time that AWS CloudFormation waits for the number of signals that was specified in the Count property.\nThe timeout period starts after AWS CloudFormation starts creating the resource, and the timeout expires no sooner\nthan the time you specify but can occur shortly thereafter. The maximum time that you can specify is 12 hours.",
|
|
376
|
+
"type": "string"
|
|
377
|
+
}
|
|
378
|
+
},
|
|
379
|
+
"type": "object"
|
|
380
|
+
},
|
|
381
|
+
"CfnUpdatePolicy": {
|
|
382
|
+
"additionalProperties": false,
|
|
383
|
+
"description": "Use the UpdatePolicy attribute to specify how AWS CloudFormation handles updates to the AWS::AutoScaling::AutoScalingGroup\nresource. AWS CloudFormation invokes one of three update policies depending on the type of change you make or whether a\nscheduled action is associated with the Auto Scaling group.",
|
|
384
|
+
"properties": {
|
|
385
|
+
"autoScalingReplacingUpdate": {
|
|
386
|
+
"$ref": "#/definitions/CfnAutoScalingReplacingUpdate",
|
|
387
|
+
"description": "Specifies whether an Auto Scaling group and the instances it contains are replaced during an update. During replacement,\nAWS CloudFormation retains the old group until it finishes creating the new one. If the update fails, AWS CloudFormation\ncan roll back to the old Auto Scaling group and delete the new Auto Scaling group."
|
|
388
|
+
},
|
|
389
|
+
"autoScalingRollingUpdate": {
|
|
390
|
+
"$ref": "#/definitions/CfnAutoScalingRollingUpdate",
|
|
391
|
+
"description": "To specify how AWS CloudFormation handles rolling updates for an Auto Scaling group, use the AutoScalingRollingUpdate\npolicy. Rolling updates enable you to specify whether AWS CloudFormation updates instances that are in an Auto Scaling\ngroup in batches or all at once."
|
|
392
|
+
},
|
|
393
|
+
"autoScalingScheduledAction": {
|
|
394
|
+
"$ref": "#/definitions/CfnAutoScalingScheduledAction",
|
|
395
|
+
"description": "To specify how AWS CloudFormation handles updates for the MinSize, MaxSize, and DesiredCapacity properties when\nthe AWS::AutoScaling::AutoScalingGroup resource has an associated scheduled action, use the AutoScalingScheduledAction\npolicy."
|
|
396
|
+
},
|
|
397
|
+
"codeDeployLambdaAliasUpdate": {
|
|
398
|
+
"$ref": "#/definitions/CfnCodeDeployLambdaAliasUpdate",
|
|
399
|
+
"description": "To perform an AWS CodeDeploy deployment when the version changes on an AWS::Lambda::Alias resource,\nuse the CodeDeployLambdaAliasUpdate update policy."
|
|
400
|
+
},
|
|
401
|
+
"enableVersionUpgrade": {
|
|
402
|
+
"description": "To upgrade an Amazon ES domain to a new version of Elasticsearch rather than replacing the entire\nAWS::Elasticsearch::Domain resource, use the EnableVersionUpgrade update policy.",
|
|
403
|
+
"type": "boolean"
|
|
404
|
+
},
|
|
405
|
+
"useOnlineResharding": {
|
|
406
|
+
"description": "To modify a replication group's shards by adding or removing shards, rather than replacing the entire\nAWS::ElastiCache::ReplicationGroup resource, use the UseOnlineResharding update policy.",
|
|
407
|
+
"type": "boolean"
|
|
408
|
+
}
|
|
409
|
+
},
|
|
410
|
+
"type": "object"
|
|
411
|
+
},
|
|
412
|
+
"Conditions": {
|
|
413
|
+
"additionalProperties": false,
|
|
414
|
+
"description": "Conditions for when an IAM Policy is in effect, specified in the following structure:\n\n`{ \"Operator\": { \"keyInRequestContext\": \"value\" } }`\n\nThe value can be either a single string value or an array of string values.\n\nFor more information, including which operators are supported, see [the IAM\ndocumentation](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html).",
|
|
415
|
+
"type": "object"
|
|
416
|
+
},
|
|
417
|
+
"Connections": {
|
|
418
|
+
"additionalProperties": false,
|
|
419
|
+
"description": "Manage the allowed network connections for constructs with Security Groups.\n\nSecurity Groups can be thought of as a firewall for network-connected\ndevices. This class makes it easy to allow network connections to and\nfrom security groups, and between security groups individually. When\nestablishing connectivity between security groups, it will automatically\nadd rules in both security groups\n\nThis object can manage one or more security groups.",
|
|
420
|
+
"properties": {
|
|
421
|
+
"_securityGroupRules": {
|
|
422
|
+
"description": "The rule that defines how to represent this peer in a security group"
|
|
423
|
+
},
|
|
424
|
+
"_securityGroups": {
|
|
425
|
+
"description": "Underlying securityGroup for this Connections object, if present\n\nMay be empty if this Connections object is not managing a SecurityGroup,\nbut simply representing a Connectable peer."
|
|
426
|
+
},
|
|
427
|
+
"connections": {
|
|
428
|
+
"$ref": "#/definitions/Connections",
|
|
429
|
+
"description": "The network connections associated with this resource."
|
|
430
|
+
},
|
|
431
|
+
"defaultPort": {
|
|
432
|
+
"$ref": "#/definitions/Port",
|
|
433
|
+
"description": "The default port configured for this connection peer, if available"
|
|
434
|
+
},
|
|
435
|
+
"remoteRule": {
|
|
436
|
+
"description": "When doing bidirectional grants between Security Groups in different stacks, put the rule on the other SG"
|
|
437
|
+
},
|
|
438
|
+
"securityGroups": {
|
|
439
|
+
"items": {
|
|
440
|
+
"$ref": "#/definitions/ISecurityGroup"
|
|
441
|
+
},
|
|
442
|
+
"type": "array"
|
|
443
|
+
},
|
|
444
|
+
"skip": {
|
|
445
|
+
"description": "When doing bidirectional grants between Connections, make sure we don't recursive infinitely"
|
|
446
|
+
}
|
|
447
|
+
},
|
|
448
|
+
"required": [
|
|
449
|
+
"_securityGroupRules",
|
|
450
|
+
"_securityGroups",
|
|
451
|
+
"connections",
|
|
452
|
+
"remoteRule",
|
|
453
|
+
"securityGroups",
|
|
454
|
+
"skip"
|
|
455
|
+
],
|
|
456
|
+
"type": "object"
|
|
457
|
+
},
|
|
458
|
+
"DockerImage": {
|
|
459
|
+
"additionalProperties": false,
|
|
460
|
+
"description": "A Docker image",
|
|
461
|
+
"properties": {
|
|
462
|
+
"image": {
|
|
463
|
+
"description": "The Docker image",
|
|
464
|
+
"type": "string"
|
|
465
|
+
}
|
|
466
|
+
},
|
|
467
|
+
"required": [
|
|
468
|
+
"image"
|
|
469
|
+
],
|
|
470
|
+
"type": "object"
|
|
471
|
+
},
|
|
472
|
+
"DomainConfig": {
|
|
473
|
+
"additionalProperties": false,
|
|
474
|
+
"properties": {
|
|
475
|
+
"blueprintIds": {
|
|
476
|
+
"additionalProperties": {
|
|
477
|
+
"type": "string"
|
|
478
|
+
},
|
|
479
|
+
"type": "object"
|
|
480
|
+
},
|
|
481
|
+
"configParamArns": {
|
|
482
|
+
"default": [],
|
|
483
|
+
"items": {
|
|
484
|
+
"type": "string"
|
|
485
|
+
},
|
|
486
|
+
"type": "array"
|
|
487
|
+
},
|
|
488
|
+
"customResourceRoleName": {
|
|
489
|
+
"type": "string"
|
|
490
|
+
},
|
|
491
|
+
"domainArn": {
|
|
492
|
+
"type": "string"
|
|
493
|
+
},
|
|
494
|
+
"domainBucketArn": {
|
|
495
|
+
"type": "string"
|
|
496
|
+
},
|
|
497
|
+
"domainBucketUsagePolicyName": {
|
|
498
|
+
"type": "string"
|
|
499
|
+
},
|
|
500
|
+
"domainConfigCr": {
|
|
501
|
+
"$ref": "#/definitions/MdaaCustomResource"
|
|
502
|
+
},
|
|
503
|
+
"domainId": {
|
|
504
|
+
"type": "string"
|
|
505
|
+
},
|
|
506
|
+
"domainKmsKeyArn": {
|
|
507
|
+
"type": "string"
|
|
508
|
+
},
|
|
509
|
+
"domainKmsUsagePolicyName": {
|
|
510
|
+
"type": "string"
|
|
511
|
+
},
|
|
512
|
+
"domainName": {
|
|
513
|
+
"type": "string"
|
|
514
|
+
},
|
|
515
|
+
"domainUnitIds": {
|
|
516
|
+
"additionalProperties": {
|
|
517
|
+
"type": "string"
|
|
518
|
+
},
|
|
519
|
+
"type": "object"
|
|
520
|
+
},
|
|
521
|
+
"domainVersion": {
|
|
522
|
+
"type": "string"
|
|
523
|
+
},
|
|
524
|
+
"glueCatalogArns": {
|
|
525
|
+
"items": {
|
|
526
|
+
"type": "string"
|
|
527
|
+
},
|
|
528
|
+
"type": "array"
|
|
529
|
+
},
|
|
530
|
+
"glueCatalogKmsKeyArns": {
|
|
531
|
+
"items": {
|
|
532
|
+
"type": "string"
|
|
533
|
+
},
|
|
534
|
+
"type": "array"
|
|
535
|
+
},
|
|
536
|
+
"node": {
|
|
537
|
+
"$ref": "#/definitions/Node",
|
|
538
|
+
"description": "The tree node."
|
|
539
|
+
},
|
|
540
|
+
"projectIds": {
|
|
541
|
+
"additionalProperties": {
|
|
542
|
+
"type": "string"
|
|
543
|
+
},
|
|
544
|
+
"type": "object"
|
|
545
|
+
},
|
|
546
|
+
"props": {
|
|
547
|
+
"$ref": "#/definitions/DomainConfigProps"
|
|
548
|
+
},
|
|
549
|
+
"ssmParamBase": {
|
|
550
|
+
"type": "string"
|
|
551
|
+
}
|
|
552
|
+
},
|
|
553
|
+
"required": [
|
|
554
|
+
"blueprintIds",
|
|
555
|
+
"configParamArns",
|
|
556
|
+
"customResourceRoleName",
|
|
557
|
+
"domainArn",
|
|
558
|
+
"domainBucketArn",
|
|
559
|
+
"domainBucketUsagePolicyName",
|
|
560
|
+
"domainConfigCr",
|
|
561
|
+
"domainId",
|
|
562
|
+
"domainKmsKeyArn",
|
|
563
|
+
"domainKmsUsagePolicyName",
|
|
564
|
+
"domainName",
|
|
565
|
+
"domainUnitIds",
|
|
566
|
+
"domainVersion",
|
|
567
|
+
"glueCatalogArns",
|
|
568
|
+
"glueCatalogKmsKeyArns",
|
|
569
|
+
"node",
|
|
570
|
+
"projectIds",
|
|
571
|
+
"props",
|
|
572
|
+
"ssmParamBase"
|
|
573
|
+
],
|
|
574
|
+
"type": "object"
|
|
575
|
+
},
|
|
576
|
+
"DomainConfigProps": {
|
|
577
|
+
"additionalProperties": false,
|
|
578
|
+
"properties": {
|
|
579
|
+
"blueprintIds": {
|
|
580
|
+
"additionalProperties": {
|
|
581
|
+
"type": "string"
|
|
582
|
+
},
|
|
583
|
+
"type": "object"
|
|
584
|
+
},
|
|
585
|
+
"createConfigParams": {
|
|
586
|
+
"type": "boolean"
|
|
587
|
+
},
|
|
588
|
+
"createOutputs": {
|
|
589
|
+
"description": "Flag controlling CloudFormation output and stack export creation for construct resources",
|
|
590
|
+
"type": "boolean"
|
|
591
|
+
},
|
|
592
|
+
"createParams": {
|
|
593
|
+
"description": "Flag controlling SSM parameter creation for construct resource references enabling",
|
|
594
|
+
"type": "boolean"
|
|
595
|
+
},
|
|
596
|
+
"customResourceRoleName": {
|
|
597
|
+
"type": "string"
|
|
598
|
+
},
|
|
599
|
+
"domainArn": {
|
|
600
|
+
"description": "DataZone domain ARN for AWS resource identification and IAM policy integration enabling",
|
|
601
|
+
"type": "string"
|
|
602
|
+
},
|
|
603
|
+
"domainBucketArn": {
|
|
604
|
+
"type": "string"
|
|
605
|
+
},
|
|
606
|
+
"domainBucketUsagePolicyName": {
|
|
607
|
+
"description": "Domain Bucket usage policy name",
|
|
608
|
+
"type": "string"
|
|
609
|
+
},
|
|
610
|
+
"domainId": {
|
|
611
|
+
"description": "DataZone domain ID for unique domain identification within AWS enabling cross-service",
|
|
612
|
+
"type": "string"
|
|
613
|
+
},
|
|
614
|
+
"domainKmsKeyArn": {
|
|
615
|
+
"description": "KMS key ARN for domain encryption ensuring data protection compliance and secure domain operations",
|
|
616
|
+
"type": "string"
|
|
617
|
+
},
|
|
618
|
+
"domainKmsUsagePolicyName": {
|
|
619
|
+
"description": "Domain KMS usage policy name for key access management enabling controlled encryption key",
|
|
620
|
+
"type": "string"
|
|
621
|
+
},
|
|
622
|
+
"domainName": {
|
|
623
|
+
"description": "DataZone domain name for domain identification and management enabling unique domain naming",
|
|
624
|
+
"type": "string"
|
|
625
|
+
},
|
|
626
|
+
"domainUnitIds": {
|
|
627
|
+
"additionalProperties": {
|
|
628
|
+
"type": "string"
|
|
629
|
+
},
|
|
630
|
+
"description": "Map of domain unit names to identifiers for hierarchical domain organization enabling",
|
|
631
|
+
"type": "object"
|
|
632
|
+
},
|
|
633
|
+
"domainVersion": {
|
|
634
|
+
"description": "Domain version for domain lifecycle management and versioning control enabling domain evolution tracking",
|
|
635
|
+
"type": "string"
|
|
636
|
+
},
|
|
637
|
+
"glueCatalogArns": {
|
|
638
|
+
"description": "Array of Glue catalog ARNs for catalog integration enabling data catalog connectivity with DataZone",
|
|
639
|
+
"items": {
|
|
640
|
+
"type": "string"
|
|
641
|
+
},
|
|
642
|
+
"type": "array"
|
|
643
|
+
},
|
|
644
|
+
"glueCatalogKmsKeyArns": {
|
|
645
|
+
"description": "Array of Glue catalog KMS key ARNs for catalog encryption enabling secure catalog integration with DataZone",
|
|
646
|
+
"items": {
|
|
647
|
+
"type": "string"
|
|
648
|
+
},
|
|
649
|
+
"type": "array"
|
|
650
|
+
},
|
|
651
|
+
"naming": {
|
|
652
|
+
"$ref": "#/definitions/IMdaaResourceNaming",
|
|
653
|
+
"description": "MDAA naming implementation for consistent resource naming across all MDAA constructs"
|
|
654
|
+
},
|
|
655
|
+
"projectIds": {
|
|
656
|
+
"additionalProperties": {
|
|
657
|
+
"type": "string"
|
|
658
|
+
},
|
|
659
|
+
"type": "object"
|
|
660
|
+
},
|
|
661
|
+
"refresh": {
|
|
662
|
+
"type": "boolean"
|
|
663
|
+
},
|
|
664
|
+
"ssmParamBase": {
|
|
665
|
+
"description": "SSM parameter base path for domain configuration storage enabling centralized configuration management",
|
|
666
|
+
"type": "string"
|
|
667
|
+
}
|
|
668
|
+
},
|
|
669
|
+
"required": [
|
|
670
|
+
"naming",
|
|
671
|
+
"ssmParamBase"
|
|
672
|
+
],
|
|
673
|
+
"type": "object"
|
|
674
|
+
},
|
|
675
|
+
"Duration": {
|
|
676
|
+
"additionalProperties": false,
|
|
677
|
+
"description": "Represents a length of time.\n\nThe amount can be specified either as a literal value (e.g: `10`) which\ncannot be negative, or as an unresolved number token.\n\nWhen the amount is passed as a token, unit conversion is not possible.",
|
|
678
|
+
"properties": {
|
|
679
|
+
"amount": {},
|
|
680
|
+
"components": {
|
|
681
|
+
"description": "Return the duration in a set of whole numbered time components, ordered from largest to smallest\n\nOnly components != 0 will be returned.\n\nCan combine millis and seconds together for the benefit of toIsoString,\nmakes the logic in there simpler."
|
|
682
|
+
},
|
|
683
|
+
"unit": {}
|
|
684
|
+
},
|
|
685
|
+
"required": [
|
|
686
|
+
"amount",
|
|
687
|
+
"components",
|
|
688
|
+
"unit"
|
|
689
|
+
],
|
|
690
|
+
"type": "object"
|
|
691
|
+
},
|
|
692
|
+
"FunctionReference": {
|
|
693
|
+
"additionalProperties": false,
|
|
694
|
+
"description": "A reference to a Function resource.",
|
|
695
|
+
"properties": {
|
|
696
|
+
"functionArn": {
|
|
697
|
+
"description": "The ARN of the Function resource.",
|
|
698
|
+
"type": "string"
|
|
699
|
+
},
|
|
700
|
+
"functionName": {
|
|
701
|
+
"description": "The FunctionName of the Function resource.",
|
|
702
|
+
"type": "string"
|
|
703
|
+
}
|
|
704
|
+
},
|
|
705
|
+
"required": [
|
|
706
|
+
"functionArn",
|
|
707
|
+
"functionName"
|
|
708
|
+
],
|
|
709
|
+
"type": "object"
|
|
710
|
+
},
|
|
711
|
+
"ICfnConditionExpression": {
|
|
712
|
+
"additionalProperties": false,
|
|
713
|
+
"description": "Represents a CloudFormation element that can be used within a Condition.\n\nYou can use intrinsic functions, such as ``Fn.conditionIf``,\n``Fn.conditionEquals``, and ``Fn.conditionNot``, to conditionally create\nstack resources. These conditions are evaluated based on input parameters\nthat you declare when you create or update a stack. After you define all your\nconditions, you can associate them with resources or resource properties in\nthe Resources and Outputs sections of a template.\n\nYou define all conditions in the Conditions section of a template except for\n``Fn.conditionIf`` conditions. You can use the ``Fn.conditionIf`` condition\nin the metadata attribute, update policy attribute, and property values in\nthe Resources section and Outputs sections of a template.\n\nYou might use conditions when you want to reuse a template that can create\nresources in different contexts, such as a test environment versus a\nproduction environment. In your template, you can add an EnvironmentType\ninput parameter, which accepts either prod or test as inputs. For the\nproduction environment, you might include Amazon EC2 instances with certain\ncapabilities; however, for the test environment, you want to use less\ncapabilities to save costs. With conditions, you can define which resources\nare created and how they're configured for each environment type.\n\nYou can use `toString` when you wish to embed a condition expression\nin a property value that accepts a `string`. For example:\n\n```ts\nnew sqs.Queue(this, 'MyQueue', {\n queueName: Fn.conditionIf('Condition', 'Hello', 'World').toString()\n});\n```",
|
|
714
|
+
"properties": {
|
|
715
|
+
"creationStack": {
|
|
716
|
+
"description": "The creation stack of this resolvable which will be appended to errors\nthrown during resolution.\n\nThis may return an array with a single informational element indicating how\nto get this property populated, if it was skipped for performance reasons.",
|
|
717
|
+
"items": {
|
|
718
|
+
"type": "string"
|
|
719
|
+
},
|
|
720
|
+
"type": "array"
|
|
721
|
+
},
|
|
722
|
+
"typeHint": {
|
|
723
|
+
"description": "The type that this token will likely resolve to.",
|
|
724
|
+
"enum": [
|
|
725
|
+
"number",
|
|
726
|
+
"string",
|
|
727
|
+
"string-list"
|
|
728
|
+
],
|
|
729
|
+
"type": "string"
|
|
730
|
+
}
|
|
731
|
+
},
|
|
732
|
+
"required": [
|
|
733
|
+
"creationStack"
|
|
734
|
+
],
|
|
735
|
+
"type": "object"
|
|
736
|
+
},
|
|
737
|
+
"ICfnResourceOptions": {
|
|
738
|
+
"additionalProperties": false,
|
|
739
|
+
"properties": {
|
|
740
|
+
"condition": {
|
|
741
|
+
"$ref": "#/definitions/CfnCondition",
|
|
742
|
+
"description": "A condition to associate with this resource. This means that only if the condition evaluates to 'true' when the stack\nis deployed, the resource will be included. This is provided to allow CDK projects to produce legacy templates, but normally\nthere is no need to use it in CDK projects."
|
|
743
|
+
},
|
|
744
|
+
"creationPolicy": {
|
|
745
|
+
"$ref": "#/definitions/CfnCreationPolicy",
|
|
746
|
+
"description": "Associate the CreationPolicy attribute with a resource to prevent its status from reaching create complete until\nAWS CloudFormation receives a specified number of success signals or the timeout period is exceeded. To signal a\nresource, you can use the cfn-signal helper script or SignalResource API. AWS CloudFormation publishes valid signals\nto the stack events so that you track the number of signals sent."
|
|
747
|
+
},
|
|
748
|
+
"deletionPolicy": {
|
|
749
|
+
"description": "With the DeletionPolicy attribute you can preserve or (in some cases) backup a resource when its stack is deleted.\nYou specify a DeletionPolicy attribute for each resource that you want to control. If a resource has no DeletionPolicy\nattribute, AWS CloudFormation deletes the resource by default. Note that this capability also applies to update operations\nthat lead to resources being removed.",
|
|
750
|
+
"enum": [
|
|
751
|
+
"Delete",
|
|
752
|
+
"Retain",
|
|
753
|
+
"RetainExceptOnCreate",
|
|
754
|
+
"Snapshot"
|
|
755
|
+
],
|
|
756
|
+
"type": "string"
|
|
757
|
+
},
|
|
758
|
+
"description": {
|
|
759
|
+
"description": "The description of this resource.\nUsed for informational purposes only, is not processed in any way\n(and stays with the CloudFormation template, is not passed to the underlying resource,\neven if it does have a 'description' property).",
|
|
760
|
+
"type": "string"
|
|
761
|
+
},
|
|
762
|
+
"metadata": {
|
|
763
|
+
"additionalProperties": {},
|
|
764
|
+
"description": "Metadata associated with the CloudFormation resource. This is not the same as the construct metadata which can be added\nusing construct.addMetadata(), but would not appear in the CloudFormation template automatically.",
|
|
765
|
+
"type": "object"
|
|
766
|
+
},
|
|
767
|
+
"updatePolicy": {
|
|
768
|
+
"$ref": "#/definitions/CfnUpdatePolicy",
|
|
769
|
+
"description": "Use the UpdatePolicy attribute to specify how AWS CloudFormation handles updates to the AWS::AutoScaling::AutoScalingGroup\nresource. AWS CloudFormation invokes one of three update policies depending on the type of change you make or whether a\nscheduled action is associated with the Auto Scaling group."
|
|
770
|
+
},
|
|
771
|
+
"updateReplacePolicy": {
|
|
772
|
+
"description": "Use the UpdateReplacePolicy attribute to retain or (in some cases) backup the existing physical instance of a resource\nwhen it is replaced during a stack update operation.",
|
|
773
|
+
"enum": [
|
|
774
|
+
"Delete",
|
|
775
|
+
"Retain",
|
|
776
|
+
"RetainExceptOnCreate",
|
|
777
|
+
"Snapshot"
|
|
778
|
+
],
|
|
779
|
+
"type": "string"
|
|
780
|
+
},
|
|
781
|
+
"version": {
|
|
782
|
+
"description": "The version of this resource.\nUsed only for custom CloudFormation resources.",
|
|
783
|
+
"type": "string"
|
|
784
|
+
}
|
|
785
|
+
},
|
|
786
|
+
"type": "object"
|
|
787
|
+
},
|
|
788
|
+
"IConstruct": {
|
|
789
|
+
"additionalProperties": false,
|
|
790
|
+
"description": "Represents a construct.",
|
|
791
|
+
"properties": {
|
|
792
|
+
"node": {
|
|
793
|
+
"$ref": "#/definitions/Node",
|
|
794
|
+
"description": "The tree node."
|
|
795
|
+
}
|
|
796
|
+
},
|
|
797
|
+
"required": [
|
|
798
|
+
"node"
|
|
799
|
+
],
|
|
800
|
+
"type": "object"
|
|
801
|
+
},
|
|
802
|
+
"IFunction": {
|
|
803
|
+
"additionalProperties": false,
|
|
804
|
+
"properties": {
|
|
805
|
+
"architecture": {
|
|
806
|
+
"$ref": "#/definitions/Architecture",
|
|
807
|
+
"description": "The system architectures compatible with this lambda function."
|
|
808
|
+
},
|
|
809
|
+
"connections": {
|
|
810
|
+
"$ref": "#/definitions/Connections",
|
|
811
|
+
"description": "The network connections associated with this resource."
|
|
812
|
+
},
|
|
813
|
+
"env": {
|
|
814
|
+
"$ref": "#/definitions/ResourceEnvironment",
|
|
815
|
+
"description": "The environment this resource belongs to.\nFor resources that are created and managed by the CDK\n(generally, those created by creating new class instances like Role, Bucket, etc.),\nthis is always the same as the environment of the stack they belong to;\nhowever, for imported resources\n(those obtained from static methods like fromRoleArn, fromBucketName, etc.),\nthat might be different than the stack they were imported into."
|
|
816
|
+
},
|
|
817
|
+
"functionArn": {
|
|
818
|
+
"description": "The ARN of the function.",
|
|
819
|
+
"type": "string"
|
|
820
|
+
},
|
|
821
|
+
"functionName": {
|
|
822
|
+
"description": "The name of the function.",
|
|
823
|
+
"type": "string"
|
|
824
|
+
},
|
|
825
|
+
"functionRef": {
|
|
826
|
+
"$ref": "#/definitions/FunctionReference",
|
|
827
|
+
"description": "A reference to a Function resource."
|
|
828
|
+
},
|
|
829
|
+
"grantPrincipal": {
|
|
830
|
+
"$ref": "#/definitions/IPrincipal",
|
|
831
|
+
"description": "The principal to grant permissions to"
|
|
832
|
+
},
|
|
833
|
+
"isBoundToVpc": {
|
|
834
|
+
"description": "Whether or not this Lambda function was bound to a VPC\n\nIf this is is `false`, trying to access the `connections` object will fail.",
|
|
835
|
+
"type": "boolean"
|
|
836
|
+
},
|
|
837
|
+
"latestVersion": {
|
|
838
|
+
"$ref": "#/definitions/IVersion",
|
|
839
|
+
"description": "The `$LATEST` version of this function.\n\nNote that this is reference to a non-specific AWS Lambda version, which\nmeans the function this version refers to can return different results in\ndifferent invocations.\n\nTo obtain a reference to an explicit version which references the current\nfunction configuration, use `lambdaFunction.currentVersion` instead."
|
|
840
|
+
},
|
|
841
|
+
"node": {
|
|
842
|
+
"$ref": "#/definitions/Node",
|
|
843
|
+
"description": "The tree node."
|
|
844
|
+
},
|
|
845
|
+
"permissionsNode": {
|
|
846
|
+
"$ref": "#/definitions/Node",
|
|
847
|
+
"description": "The construct node where permissions are attached."
|
|
848
|
+
},
|
|
849
|
+
"resourceArnsForGrantInvoke": {
|
|
850
|
+
"description": "The ARN(s) to put into the resource field of the generated IAM policy for grantInvoke().\n\nThis property is for cdk modules to consume only. You should not need to use this property.\nInstead, use grantInvoke() directly.",
|
|
851
|
+
"items": {
|
|
852
|
+
"type": "string"
|
|
853
|
+
},
|
|
854
|
+
"type": "array"
|
|
855
|
+
},
|
|
856
|
+
"role": {
|
|
857
|
+
"$ref": "#/definitions/IRole",
|
|
858
|
+
"description": "The IAM role associated with this function."
|
|
859
|
+
},
|
|
860
|
+
"stack": {
|
|
861
|
+
"$ref": "#/definitions/Stack",
|
|
862
|
+
"description": "The stack in which this resource is defined."
|
|
863
|
+
}
|
|
864
|
+
},
|
|
865
|
+
"required": [
|
|
866
|
+
"architecture",
|
|
867
|
+
"connections",
|
|
868
|
+
"env",
|
|
869
|
+
"functionArn",
|
|
870
|
+
"functionName",
|
|
871
|
+
"functionRef",
|
|
872
|
+
"grantPrincipal",
|
|
873
|
+
"isBoundToVpc",
|
|
874
|
+
"latestVersion",
|
|
875
|
+
"node",
|
|
876
|
+
"permissionsNode",
|
|
877
|
+
"resourceArnsForGrantInvoke",
|
|
878
|
+
"stack"
|
|
879
|
+
],
|
|
880
|
+
"type": "object"
|
|
881
|
+
},
|
|
882
|
+
"IKey": {
|
|
883
|
+
"additionalProperties": false,
|
|
884
|
+
"description": "A KMS Key, either managed by this CDK app, or imported.\n\nThis interface does double duty: it represents an actual KMS keys, but it\nalso represents things that can behave like KMS keys, like a key alias.",
|
|
885
|
+
"properties": {
|
|
886
|
+
"env": {
|
|
887
|
+
"$ref": "#/definitions/ResourceEnvironment",
|
|
888
|
+
"description": "The environment this resource belongs to.\nFor resources that are created and managed by the CDK\n(generally, those created by creating new class instances like Role, Bucket, etc.),\nthis is always the same as the environment of the stack they belong to;\nhowever, for imported resources\n(those obtained from static methods like fromRoleArn, fromBucketName, etc.),\nthat might be different than the stack they were imported into."
|
|
889
|
+
},
|
|
890
|
+
"keyArn": {
|
|
891
|
+
"description": "The ARN of the key.",
|
|
892
|
+
"type": "string"
|
|
893
|
+
},
|
|
894
|
+
"keyId": {
|
|
895
|
+
"description": "The ID of the key\n(the part that looks something like: 1234abcd-12ab-34cd-56ef-1234567890ab).",
|
|
896
|
+
"type": "string"
|
|
897
|
+
},
|
|
898
|
+
"keyRef": {
|
|
899
|
+
"$ref": "#/definitions/KeyReference",
|
|
900
|
+
"description": "A reference to a Key resource."
|
|
901
|
+
},
|
|
902
|
+
"node": {
|
|
903
|
+
"$ref": "#/definitions/Node",
|
|
904
|
+
"description": "The tree node."
|
|
905
|
+
},
|
|
906
|
+
"stack": {
|
|
907
|
+
"$ref": "#/definitions/Stack",
|
|
908
|
+
"description": "The stack in which this resource is defined."
|
|
909
|
+
}
|
|
910
|
+
},
|
|
911
|
+
"required": [
|
|
912
|
+
"env",
|
|
913
|
+
"keyArn",
|
|
914
|
+
"keyId",
|
|
915
|
+
"keyRef",
|
|
916
|
+
"node",
|
|
917
|
+
"stack"
|
|
918
|
+
],
|
|
919
|
+
"type": "object"
|
|
920
|
+
},
|
|
921
|
+
"ILayerVersion": {
|
|
922
|
+
"additionalProperties": false,
|
|
923
|
+
"properties": {
|
|
924
|
+
"compatibleRuntimes": {
|
|
925
|
+
"default": "- All supported runtimes. Setting this to Runtime.ALL is equivalent to leaving it undefined.",
|
|
926
|
+
"description": "The runtimes compatible with this Layer.",
|
|
927
|
+
"items": {
|
|
928
|
+
"$ref": "#/definitions/Runtime"
|
|
929
|
+
},
|
|
930
|
+
"type": "array"
|
|
931
|
+
},
|
|
932
|
+
"env": {
|
|
933
|
+
"$ref": "#/definitions/ResourceEnvironment",
|
|
934
|
+
"description": "The environment this resource belongs to.\nFor resources that are created and managed by the CDK\n(generally, those created by creating new class instances like Role, Bucket, etc.),\nthis is always the same as the environment of the stack they belong to;\nhowever, for imported resources\n(those obtained from static methods like fromRoleArn, fromBucketName, etc.),\nthat might be different than the stack they were imported into."
|
|
935
|
+
},
|
|
936
|
+
"layerVersionArn": {
|
|
937
|
+
"description": "The ARN of the Lambda Layer version that this Layer defines.",
|
|
938
|
+
"type": "string"
|
|
939
|
+
},
|
|
940
|
+
"layerVersionRef": {
|
|
941
|
+
"$ref": "#/definitions/LayerVersionReference",
|
|
942
|
+
"description": "A reference to a LayerVersion resource."
|
|
943
|
+
},
|
|
944
|
+
"node": {
|
|
945
|
+
"$ref": "#/definitions/Node",
|
|
946
|
+
"description": "The tree node."
|
|
947
|
+
},
|
|
948
|
+
"stack": {
|
|
949
|
+
"$ref": "#/definitions/Stack",
|
|
950
|
+
"description": "The stack in which this resource is defined."
|
|
951
|
+
}
|
|
952
|
+
},
|
|
953
|
+
"required": [
|
|
954
|
+
"env",
|
|
955
|
+
"layerVersionArn",
|
|
956
|
+
"layerVersionRef",
|
|
957
|
+
"node",
|
|
958
|
+
"stack"
|
|
959
|
+
],
|
|
960
|
+
"type": "object"
|
|
961
|
+
},
|
|
962
|
+
"ILogGroup": {
|
|
963
|
+
"additionalProperties": false,
|
|
964
|
+
"properties": {
|
|
965
|
+
"env": {
|
|
966
|
+
"$ref": "#/definitions/ResourceEnvironment",
|
|
967
|
+
"description": "The environment this resource belongs to.\nFor resources that are created and managed by the CDK\n(generally, those created by creating new class instances like Role, Bucket, etc.),\nthis is always the same as the environment of the stack they belong to;\nhowever, for imported resources\n(those obtained from static methods like fromRoleArn, fromBucketName, etc.),\nthat might be different than the stack they were imported into."
|
|
968
|
+
},
|
|
969
|
+
"logGroupArn": {
|
|
970
|
+
"description": "The ARN of this log group, with ':*' appended",
|
|
971
|
+
"type": "string"
|
|
972
|
+
},
|
|
973
|
+
"logGroupName": {
|
|
974
|
+
"description": "The name of this log group",
|
|
975
|
+
"type": "string"
|
|
976
|
+
},
|
|
977
|
+
"node": {
|
|
978
|
+
"$ref": "#/definitions/Node",
|
|
979
|
+
"description": "The tree node."
|
|
980
|
+
},
|
|
981
|
+
"stack": {
|
|
982
|
+
"$ref": "#/definitions/Stack",
|
|
983
|
+
"description": "The stack in which this resource is defined."
|
|
984
|
+
}
|
|
985
|
+
},
|
|
986
|
+
"required": [
|
|
987
|
+
"env",
|
|
988
|
+
"logGroupArn",
|
|
989
|
+
"logGroupName",
|
|
990
|
+
"node",
|
|
991
|
+
"stack"
|
|
992
|
+
],
|
|
993
|
+
"type": "object"
|
|
994
|
+
},
|
|
995
|
+
"IMdaaResourceNaming": {
|
|
996
|
+
"additionalProperties": false,
|
|
997
|
+
"properties": {
|
|
998
|
+
"props": {
|
|
999
|
+
"$ref": "#/definitions/MdaaResourceNamingConfig",
|
|
1000
|
+
"description": "Configuration properties containing organizational context and CDK node access for the naming implementation"
|
|
1001
|
+
}
|
|
1002
|
+
},
|
|
1003
|
+
"required": [
|
|
1004
|
+
"props"
|
|
1005
|
+
],
|
|
1006
|
+
"type": "object"
|
|
1007
|
+
},
|
|
1008
|
+
"IPrincipal": {
|
|
1009
|
+
"additionalProperties": false,
|
|
1010
|
+
"description": "Represents a logical IAM principal.\n\nAn IPrincipal describes a logical entity that can perform AWS API calls\nagainst sets of resources, optionally under certain conditions.\n\nExamples of simple principals are IAM objects that you create, such\nas Users or Roles.\n\nAn example of a more complex principals is a `ServicePrincipal` (such as\n`new ServicePrincipal(\"sns.amazonaws.com\")`, which represents the Simple\nNotifications Service).\n\nA single logical Principal may also map to a set of physical principals.\nFor example, `new OrganizationPrincipal('o-12345abcde')` represents all\nidentities that are part of the given AWS Organization.",
|
|
1011
|
+
"properties": {
|
|
1012
|
+
"assumeRoleAction": {
|
|
1013
|
+
"description": "When this Principal is used in an AssumeRole policy, the action to use.",
|
|
1014
|
+
"type": "string"
|
|
1015
|
+
},
|
|
1016
|
+
"grantPrincipal": {
|
|
1017
|
+
"$ref": "#/definitions/IPrincipal",
|
|
1018
|
+
"description": "The principal to grant permissions to"
|
|
1019
|
+
},
|
|
1020
|
+
"policyFragment": {
|
|
1021
|
+
"$ref": "#/definitions/PrincipalPolicyFragment",
|
|
1022
|
+
"description": "Return the policy fragment that identifies this principal in a Policy."
|
|
1023
|
+
},
|
|
1024
|
+
"principalAccount": {
|
|
1025
|
+
"description": "The AWS account ID of this principal.\nCan be undefined when the account is not known\n(for example, for service principals).\nCan be a Token - in that case,\nit's assumed to be AWS::AccountId.",
|
|
1026
|
+
"type": "string"
|
|
1027
|
+
}
|
|
1028
|
+
},
|
|
1029
|
+
"required": [
|
|
1030
|
+
"assumeRoleAction",
|
|
1031
|
+
"grantPrincipal",
|
|
1032
|
+
"policyFragment"
|
|
1033
|
+
],
|
|
1034
|
+
"type": "object"
|
|
1035
|
+
},
|
|
1036
|
+
"IQueue": {
|
|
1037
|
+
"additionalProperties": false,
|
|
1038
|
+
"description": "Represents an SQS queue",
|
|
1039
|
+
"properties": {
|
|
1040
|
+
"encryptionMasterKey": {
|
|
1041
|
+
"$ref": "#/definitions/IKey",
|
|
1042
|
+
"description": "If this queue is server-side encrypted, this is the KMS encryption key."
|
|
1043
|
+
},
|
|
1044
|
+
"encryptionType": {
|
|
1045
|
+
"description": "Whether the contents of the queue are encrypted, and by what type of key.",
|
|
1046
|
+
"enum": [
|
|
1047
|
+
"KMS",
|
|
1048
|
+
"KMS_MANAGED",
|
|
1049
|
+
"NONE",
|
|
1050
|
+
"SQS_MANAGED"
|
|
1051
|
+
],
|
|
1052
|
+
"type": "string"
|
|
1053
|
+
},
|
|
1054
|
+
"env": {
|
|
1055
|
+
"$ref": "#/definitions/ResourceEnvironment",
|
|
1056
|
+
"description": "The environment this resource belongs to.\nFor resources that are created and managed by the CDK\n(generally, those created by creating new class instances like Role, Bucket, etc.),\nthis is always the same as the environment of the stack they belong to;\nhowever, for imported resources\n(those obtained from static methods like fromRoleArn, fromBucketName, etc.),\nthat might be different than the stack they were imported into."
|
|
1057
|
+
},
|
|
1058
|
+
"fifo": {
|
|
1059
|
+
"description": "Whether this queue is an Amazon SQS FIFO queue. If false, this is a standard queue.",
|
|
1060
|
+
"type": "boolean"
|
|
1061
|
+
},
|
|
1062
|
+
"node": {
|
|
1063
|
+
"$ref": "#/definitions/Node",
|
|
1064
|
+
"description": "The tree node."
|
|
1065
|
+
},
|
|
1066
|
+
"queueArn": {
|
|
1067
|
+
"description": "The ARN of this queue",
|
|
1068
|
+
"type": "string"
|
|
1069
|
+
},
|
|
1070
|
+
"queueName": {
|
|
1071
|
+
"description": "The name of this queue",
|
|
1072
|
+
"type": "string"
|
|
1073
|
+
},
|
|
1074
|
+
"queueUrl": {
|
|
1075
|
+
"description": "The URL of this queue",
|
|
1076
|
+
"type": "string"
|
|
1077
|
+
},
|
|
1078
|
+
"stack": {
|
|
1079
|
+
"$ref": "#/definitions/Stack",
|
|
1080
|
+
"description": "The stack in which this resource is defined."
|
|
1081
|
+
}
|
|
1082
|
+
},
|
|
1083
|
+
"required": [
|
|
1084
|
+
"env",
|
|
1085
|
+
"fifo",
|
|
1086
|
+
"node",
|
|
1087
|
+
"queueArn",
|
|
1088
|
+
"queueName",
|
|
1089
|
+
"queueUrl",
|
|
1090
|
+
"stack"
|
|
1091
|
+
],
|
|
1092
|
+
"type": "object"
|
|
1093
|
+
},
|
|
1094
|
+
"IResolvable": {
|
|
1095
|
+
"additionalProperties": false,
|
|
1096
|
+
"description": "Interface for values that can be resolvable later\n\nTokens are special objects that participate in synthesis.",
|
|
1097
|
+
"properties": {
|
|
1098
|
+
"creationStack": {
|
|
1099
|
+
"description": "The creation stack of this resolvable which will be appended to errors\nthrown during resolution.\n\nThis may return an array with a single informational element indicating how\nto get this property populated, if it was skipped for performance reasons.",
|
|
1100
|
+
"items": {
|
|
1101
|
+
"type": "string"
|
|
1102
|
+
},
|
|
1103
|
+
"type": "array"
|
|
1104
|
+
},
|
|
1105
|
+
"typeHint": {
|
|
1106
|
+
"description": "The type that this token will likely resolve to.",
|
|
1107
|
+
"enum": [
|
|
1108
|
+
"number",
|
|
1109
|
+
"string",
|
|
1110
|
+
"string-list"
|
|
1111
|
+
],
|
|
1112
|
+
"type": "string"
|
|
1113
|
+
}
|
|
1114
|
+
},
|
|
1115
|
+
"required": [
|
|
1116
|
+
"creationStack"
|
|
1117
|
+
],
|
|
1118
|
+
"type": "object"
|
|
1119
|
+
},
|
|
1120
|
+
"IRole": {
|
|
1121
|
+
"additionalProperties": false,
|
|
1122
|
+
"description": "A Role object",
|
|
1123
|
+
"properties": {
|
|
1124
|
+
"assumeRoleAction": {
|
|
1125
|
+
"description": "When this Principal is used in an AssumeRole policy, the action to use.",
|
|
1126
|
+
"type": "string"
|
|
1127
|
+
},
|
|
1128
|
+
"env": {
|
|
1129
|
+
"$ref": "#/definitions/ResourceEnvironment",
|
|
1130
|
+
"description": "The environment this resource belongs to.\nFor resources that are created and managed by the CDK\n(generally, those created by creating new class instances like Role, Bucket, etc.),\nthis is always the same as the environment of the stack they belong to;\nhowever, for imported resources\n(those obtained from static methods like fromRoleArn, fromBucketName, etc.),\nthat might be different than the stack they were imported into."
|
|
1131
|
+
},
|
|
1132
|
+
"grantPrincipal": {
|
|
1133
|
+
"$ref": "#/definitions/IPrincipal",
|
|
1134
|
+
"description": "The principal to grant permissions to"
|
|
1135
|
+
},
|
|
1136
|
+
"node": {
|
|
1137
|
+
"$ref": "#/definitions/Node",
|
|
1138
|
+
"description": "The tree node."
|
|
1139
|
+
},
|
|
1140
|
+
"policyFragment": {
|
|
1141
|
+
"$ref": "#/definitions/PrincipalPolicyFragment",
|
|
1142
|
+
"description": "Return the policy fragment that identifies this principal in a Policy."
|
|
1143
|
+
},
|
|
1144
|
+
"principalAccount": {
|
|
1145
|
+
"description": "The AWS account ID of this principal.\nCan be undefined when the account is not known\n(for example, for service principals).\nCan be a Token - in that case,\nit's assumed to be AWS::AccountId.",
|
|
1146
|
+
"type": "string"
|
|
1147
|
+
},
|
|
1148
|
+
"roleArn": {
|
|
1149
|
+
"description": "Returns the ARN of this role.",
|
|
1150
|
+
"type": "string"
|
|
1151
|
+
},
|
|
1152
|
+
"roleName": {
|
|
1153
|
+
"description": "Returns the name of this role.",
|
|
1154
|
+
"type": "string"
|
|
1155
|
+
},
|
|
1156
|
+
"roleRef": {
|
|
1157
|
+
"$ref": "#/definitions/RoleReference",
|
|
1158
|
+
"description": "A reference to a Role resource."
|
|
1159
|
+
},
|
|
1160
|
+
"stack": {
|
|
1161
|
+
"$ref": "#/definitions/Stack",
|
|
1162
|
+
"description": "The stack in which this resource is defined."
|
|
1163
|
+
}
|
|
1164
|
+
},
|
|
1165
|
+
"required": [
|
|
1166
|
+
"assumeRoleAction",
|
|
1167
|
+
"env",
|
|
1168
|
+
"grantPrincipal",
|
|
1169
|
+
"node",
|
|
1170
|
+
"policyFragment",
|
|
1171
|
+
"roleArn",
|
|
1172
|
+
"roleName",
|
|
1173
|
+
"roleRef",
|
|
1174
|
+
"stack"
|
|
1175
|
+
],
|
|
1176
|
+
"type": "object"
|
|
1177
|
+
},
|
|
1178
|
+
"ISecurityGroup": {
|
|
1179
|
+
"additionalProperties": false,
|
|
1180
|
+
"description": "Interface for security group-like objects",
|
|
1181
|
+
"properties": {
|
|
1182
|
+
"allowAllOutbound": {
|
|
1183
|
+
"description": "Whether the SecurityGroup has been configured to allow all outbound traffic",
|
|
1184
|
+
"type": "boolean"
|
|
1185
|
+
},
|
|
1186
|
+
"canInlineRule": {
|
|
1187
|
+
"description": "Whether the rule can be inlined into a SecurityGroup or not",
|
|
1188
|
+
"type": "boolean"
|
|
1189
|
+
},
|
|
1190
|
+
"connections": {
|
|
1191
|
+
"$ref": "#/definitions/Connections",
|
|
1192
|
+
"description": "The network connections associated with this resource."
|
|
1193
|
+
},
|
|
1194
|
+
"env": {
|
|
1195
|
+
"$ref": "#/definitions/ResourceEnvironment",
|
|
1196
|
+
"description": "The environment this resource belongs to.\nFor resources that are created and managed by the CDK\n(generally, those created by creating new class instances like Role, Bucket, etc.),\nthis is always the same as the environment of the stack they belong to;\nhowever, for imported resources\n(those obtained from static methods like fromRoleArn, fromBucketName, etc.),\nthat might be different than the stack they were imported into."
|
|
1197
|
+
},
|
|
1198
|
+
"node": {
|
|
1199
|
+
"$ref": "#/definitions/Node",
|
|
1200
|
+
"description": "The tree node."
|
|
1201
|
+
},
|
|
1202
|
+
"securityGroupId": {
|
|
1203
|
+
"description": "ID for the current security group",
|
|
1204
|
+
"type": "string"
|
|
1205
|
+
},
|
|
1206
|
+
"securityGroupRef": {
|
|
1207
|
+
"$ref": "#/definitions/SecurityGroupReference",
|
|
1208
|
+
"description": "A reference to a SecurityGroup resource."
|
|
1209
|
+
},
|
|
1210
|
+
"stack": {
|
|
1211
|
+
"$ref": "#/definitions/Stack",
|
|
1212
|
+
"description": "The stack in which this resource is defined."
|
|
1213
|
+
},
|
|
1214
|
+
"uniqueId": {
|
|
1215
|
+
"description": "A unique identifier for this connection peer",
|
|
1216
|
+
"type": "string"
|
|
1217
|
+
}
|
|
1218
|
+
},
|
|
1219
|
+
"required": [
|
|
1220
|
+
"allowAllOutbound",
|
|
1221
|
+
"canInlineRule",
|
|
1222
|
+
"connections",
|
|
1223
|
+
"env",
|
|
1224
|
+
"node",
|
|
1225
|
+
"securityGroupId",
|
|
1226
|
+
"securityGroupRef",
|
|
1227
|
+
"stack",
|
|
1228
|
+
"uniqueId"
|
|
1229
|
+
],
|
|
1230
|
+
"type": "object"
|
|
1231
|
+
},
|
|
1232
|
+
"IStackSynthesizer": {
|
|
1233
|
+
"additionalProperties": false,
|
|
1234
|
+
"description": "Encodes information how a certain Stack should be deployed",
|
|
1235
|
+
"properties": {
|
|
1236
|
+
"bootstrapQualifier": {
|
|
1237
|
+
"default": "- no qualifier",
|
|
1238
|
+
"description": "The qualifier used to bootstrap this stack",
|
|
1239
|
+
"type": "string"
|
|
1240
|
+
},
|
|
1241
|
+
"lookupRole": {
|
|
1242
|
+
"default": "- no role",
|
|
1243
|
+
"description": "The role used to lookup for this stack",
|
|
1244
|
+
"type": "string"
|
|
1245
|
+
}
|
|
1246
|
+
},
|
|
1247
|
+
"type": "object"
|
|
1248
|
+
},
|
|
1249
|
+
"ITemplateOptions": {
|
|
1250
|
+
"additionalProperties": false,
|
|
1251
|
+
"description": "CloudFormation template options for a stack.",
|
|
1252
|
+
"properties": {
|
|
1253
|
+
"description": {
|
|
1254
|
+
"description": "Gets or sets the description of this stack.\nIf provided, it will be included in the CloudFormation template's \"Description\" attribute.",
|
|
1255
|
+
"type": "string"
|
|
1256
|
+
},
|
|
1257
|
+
"metadata": {
|
|
1258
|
+
"additionalProperties": {},
|
|
1259
|
+
"description": "Metadata associated with the CloudFormation template.",
|
|
1260
|
+
"type": "object"
|
|
1261
|
+
},
|
|
1262
|
+
"templateFormatVersion": {
|
|
1263
|
+
"description": "Gets or sets the AWSTemplateFormatVersion field of the CloudFormation template.",
|
|
1264
|
+
"type": "string"
|
|
1265
|
+
},
|
|
1266
|
+
"transforms": {
|
|
1267
|
+
"description": "Gets or sets the top-level template transform(s) for this stack (e.g. `[\"AWS::Serverless-2016-10-31\"]`).",
|
|
1268
|
+
"items": {
|
|
1269
|
+
"type": "string"
|
|
1270
|
+
},
|
|
1271
|
+
"type": "array"
|
|
1272
|
+
}
|
|
1273
|
+
},
|
|
1274
|
+
"type": "object"
|
|
1275
|
+
},
|
|
1276
|
+
"ITopic": {
|
|
1277
|
+
"additionalProperties": false,
|
|
1278
|
+
"description": "Represents an SNS topic",
|
|
1279
|
+
"properties": {
|
|
1280
|
+
"contentBasedDeduplication": {
|
|
1281
|
+
"description": "Enables content-based deduplication for FIFO topics.",
|
|
1282
|
+
"type": "boolean"
|
|
1283
|
+
},
|
|
1284
|
+
"env": {
|
|
1285
|
+
"$ref": "#/definitions/ResourceEnvironment",
|
|
1286
|
+
"description": "The environment this resource belongs to.\nFor resources that are created and managed by the CDK\n(generally, those created by creating new class instances like Role, Bucket, etc.),\nthis is always the same as the environment of the stack they belong to;\nhowever, for imported resources\n(those obtained from static methods like fromRoleArn, fromBucketName, etc.),\nthat might be different than the stack they were imported into."
|
|
1287
|
+
},
|
|
1288
|
+
"fifo": {
|
|
1289
|
+
"description": "Whether this topic is an Amazon SNS FIFO queue. If false, this is a standard topic.",
|
|
1290
|
+
"type": "boolean"
|
|
1291
|
+
},
|
|
1292
|
+
"masterKey": {
|
|
1293
|
+
"$ref": "#/definitions/IKey",
|
|
1294
|
+
"default": "None",
|
|
1295
|
+
"description": "A KMS Key, either managed by this CDK app, or imported.\n\nThis property applies only to server-side encryption."
|
|
1296
|
+
},
|
|
1297
|
+
"node": {
|
|
1298
|
+
"$ref": "#/definitions/Node",
|
|
1299
|
+
"description": "The tree node."
|
|
1300
|
+
},
|
|
1301
|
+
"stack": {
|
|
1302
|
+
"$ref": "#/definitions/Stack",
|
|
1303
|
+
"description": "The stack in which this resource is defined."
|
|
1304
|
+
},
|
|
1305
|
+
"topicArn": {
|
|
1306
|
+
"description": "The ARN of the topic",
|
|
1307
|
+
"type": "string"
|
|
1308
|
+
},
|
|
1309
|
+
"topicName": {
|
|
1310
|
+
"description": "The name of the topic",
|
|
1311
|
+
"type": "string"
|
|
1312
|
+
}
|
|
1313
|
+
},
|
|
1314
|
+
"required": [
|
|
1315
|
+
"contentBasedDeduplication",
|
|
1316
|
+
"env",
|
|
1317
|
+
"fifo",
|
|
1318
|
+
"node",
|
|
1319
|
+
"stack",
|
|
1320
|
+
"topicArn",
|
|
1321
|
+
"topicName"
|
|
1322
|
+
],
|
|
1323
|
+
"type": "object"
|
|
1324
|
+
},
|
|
1325
|
+
"IVersion": {
|
|
1326
|
+
"additionalProperties": false,
|
|
1327
|
+
"properties": {
|
|
1328
|
+
"architecture": {
|
|
1329
|
+
"$ref": "#/definitions/Architecture",
|
|
1330
|
+
"description": "The system architectures compatible with this lambda function."
|
|
1331
|
+
},
|
|
1332
|
+
"connections": {
|
|
1333
|
+
"$ref": "#/definitions/Connections",
|
|
1334
|
+
"description": "The network connections associated with this resource."
|
|
1335
|
+
},
|
|
1336
|
+
"edgeArn": {
|
|
1337
|
+
"description": "The ARN of the version for Lambda@Edge.",
|
|
1338
|
+
"type": "string"
|
|
1339
|
+
},
|
|
1340
|
+
"env": {
|
|
1341
|
+
"$ref": "#/definitions/ResourceEnvironment",
|
|
1342
|
+
"description": "The environment this resource belongs to.\nFor resources that are created and managed by the CDK\n(generally, those created by creating new class instances like Role, Bucket, etc.),\nthis is always the same as the environment of the stack they belong to;\nhowever, for imported resources\n(those obtained from static methods like fromRoleArn, fromBucketName, etc.),\nthat might be different than the stack they were imported into."
|
|
1343
|
+
},
|
|
1344
|
+
"functionArn": {
|
|
1345
|
+
"description": "The ARN of the function.",
|
|
1346
|
+
"type": "string"
|
|
1347
|
+
},
|
|
1348
|
+
"functionName": {
|
|
1349
|
+
"description": "The name of the function.",
|
|
1350
|
+
"type": "string"
|
|
1351
|
+
},
|
|
1352
|
+
"functionRef": {
|
|
1353
|
+
"$ref": "#/definitions/FunctionReference",
|
|
1354
|
+
"description": "A reference to a Function resource."
|
|
1355
|
+
},
|
|
1356
|
+
"grantPrincipal": {
|
|
1357
|
+
"$ref": "#/definitions/IPrincipal",
|
|
1358
|
+
"description": "The principal to grant permissions to"
|
|
1359
|
+
},
|
|
1360
|
+
"isBoundToVpc": {
|
|
1361
|
+
"description": "Whether or not this Lambda function was bound to a VPC\n\nIf this is is `false`, trying to access the `connections` object will fail.",
|
|
1362
|
+
"type": "boolean"
|
|
1363
|
+
},
|
|
1364
|
+
"lambda": {
|
|
1365
|
+
"$ref": "#/definitions/IFunction",
|
|
1366
|
+
"description": "The underlying AWS Lambda function."
|
|
1367
|
+
},
|
|
1368
|
+
"latestVersion": {
|
|
1369
|
+
"$ref": "#/definitions/IVersion",
|
|
1370
|
+
"description": "The `$LATEST` version of this function.\n\nNote that this is reference to a non-specific AWS Lambda version, which\nmeans the function this version refers to can return different results in\ndifferent invocations.\n\nTo obtain a reference to an explicit version which references the current\nfunction configuration, use `lambdaFunction.currentVersion` instead."
|
|
1371
|
+
},
|
|
1372
|
+
"node": {
|
|
1373
|
+
"$ref": "#/definitions/Node",
|
|
1374
|
+
"description": "The tree node."
|
|
1375
|
+
},
|
|
1376
|
+
"permissionsNode": {
|
|
1377
|
+
"$ref": "#/definitions/Node",
|
|
1378
|
+
"description": "The construct node where permissions are attached."
|
|
1379
|
+
},
|
|
1380
|
+
"resourceArnsForGrantInvoke": {
|
|
1381
|
+
"description": "The ARN(s) to put into the resource field of the generated IAM policy for grantInvoke().\n\nThis property is for cdk modules to consume only. You should not need to use this property.\nInstead, use grantInvoke() directly.",
|
|
1382
|
+
"items": {
|
|
1383
|
+
"type": "string"
|
|
1384
|
+
},
|
|
1385
|
+
"type": "array"
|
|
1386
|
+
},
|
|
1387
|
+
"role": {
|
|
1388
|
+
"$ref": "#/definitions/IRole",
|
|
1389
|
+
"description": "The IAM role associated with this function."
|
|
1390
|
+
},
|
|
1391
|
+
"stack": {
|
|
1392
|
+
"$ref": "#/definitions/Stack",
|
|
1393
|
+
"description": "The stack in which this resource is defined."
|
|
1394
|
+
},
|
|
1395
|
+
"version": {
|
|
1396
|
+
"description": "The most recently deployed version of this function.",
|
|
1397
|
+
"type": "string"
|
|
1398
|
+
},
|
|
1399
|
+
"versionRef": {
|
|
1400
|
+
"$ref": "#/definitions/VersionReference",
|
|
1401
|
+
"description": "A reference to a Version resource."
|
|
1402
|
+
}
|
|
1403
|
+
},
|
|
1404
|
+
"required": [
|
|
1405
|
+
"architecture",
|
|
1406
|
+
"connections",
|
|
1407
|
+
"edgeArn",
|
|
1408
|
+
"env",
|
|
1409
|
+
"functionArn",
|
|
1410
|
+
"functionName",
|
|
1411
|
+
"functionRef",
|
|
1412
|
+
"grantPrincipal",
|
|
1413
|
+
"isBoundToVpc",
|
|
1414
|
+
"lambda",
|
|
1415
|
+
"latestVersion",
|
|
1416
|
+
"node",
|
|
1417
|
+
"permissionsNode",
|
|
1418
|
+
"resourceArnsForGrantInvoke",
|
|
1419
|
+
"stack",
|
|
1420
|
+
"version",
|
|
1421
|
+
"versionRef"
|
|
1422
|
+
],
|
|
1423
|
+
"type": "object"
|
|
1424
|
+
},
|
|
1425
|
+
"KeyReference": {
|
|
1426
|
+
"additionalProperties": false,
|
|
1427
|
+
"description": "A reference to a Key resource.",
|
|
1428
|
+
"properties": {
|
|
1429
|
+
"keyArn": {
|
|
1430
|
+
"description": "The ARN of the Key resource.",
|
|
1431
|
+
"type": "string"
|
|
1432
|
+
},
|
|
1433
|
+
"keyId": {
|
|
1434
|
+
"description": "The KeyId of the Key resource.",
|
|
1435
|
+
"type": "string"
|
|
1436
|
+
}
|
|
1437
|
+
},
|
|
1438
|
+
"required": [
|
|
1439
|
+
"keyArn",
|
|
1440
|
+
"keyId"
|
|
1441
|
+
],
|
|
1442
|
+
"type": "object"
|
|
1443
|
+
},
|
|
1444
|
+
"LayerVersionReference": {
|
|
1445
|
+
"additionalProperties": false,
|
|
1446
|
+
"description": "A reference to a LayerVersion resource.",
|
|
1447
|
+
"properties": {
|
|
1448
|
+
"layerVersionArn": {
|
|
1449
|
+
"description": "The LayerVersionArn of the LayerVersion resource.",
|
|
1450
|
+
"type": "string"
|
|
1451
|
+
}
|
|
1452
|
+
},
|
|
1453
|
+
"required": [
|
|
1454
|
+
"layerVersionArn"
|
|
1455
|
+
],
|
|
1456
|
+
"type": "object"
|
|
1457
|
+
},
|
|
1458
|
+
"LogRetention": {
|
|
1459
|
+
"additionalProperties": false,
|
|
1460
|
+
"description": "Creates a custom resource to control the retention policy of a CloudWatch Logs\nlog group. The log group is created if it doesn't already exist. The policy\nis removed when `retentionDays` is `undefined` or equal to `Infinity`.\nLog group can be created in the region that is different from stack region by\nspecifying `logGroupRegion`",
|
|
1461
|
+
"properties": {
|
|
1462
|
+
"ensureSingletonLogRetentionFunction": {
|
|
1463
|
+
"description": "Helper method to ensure that only one instance of LogRetentionFunction resources are in the stack mimicking the\nbehaviour of aws-cdk-lib/aws-lambda's SingletonFunction to prevent circular dependencies"
|
|
1464
|
+
},
|
|
1465
|
+
"logGroupArn": {
|
|
1466
|
+
"description": "The ARN of the LogGroup.",
|
|
1467
|
+
"type": "string"
|
|
1468
|
+
},
|
|
1469
|
+
"node": {
|
|
1470
|
+
"$ref": "#/definitions/Node",
|
|
1471
|
+
"description": "The tree node."
|
|
1472
|
+
}
|
|
1473
|
+
},
|
|
1474
|
+
"required": [
|
|
1475
|
+
"ensureSingletonLogRetentionFunction",
|
|
1476
|
+
"logGroupArn",
|
|
1477
|
+
"node"
|
|
1478
|
+
],
|
|
1479
|
+
"type": "object"
|
|
1480
|
+
},
|
|
1481
|
+
"MdaaCustomResource": {
|
|
1482
|
+
"additionalProperties": false,
|
|
1483
|
+
"properties": {
|
|
1484
|
+
"_allowCrossEnvironment": {},
|
|
1485
|
+
"_physicalName": {},
|
|
1486
|
+
"env": {
|
|
1487
|
+
"$ref": "#/definitions/ResourceEnvironment",
|
|
1488
|
+
"description": "The environment this resource belongs to.\nFor resources that are created and managed by the CDK\n(generally, those created by creating new class instances like Role, Bucket, etc.),\nthis is always the same as the environment of the stack they belong to;\nhowever, for imported resources\n(those obtained from static methods like fromRoleArn, fromBucketName, etc.),\nthat might be different than the stack they were imported into."
|
|
1489
|
+
},
|
|
1490
|
+
"handlerFunction": {
|
|
1491
|
+
"$ref": "#/definitions/MdaaLambdaFunction"
|
|
1492
|
+
},
|
|
1493
|
+
"node": {
|
|
1494
|
+
"$ref": "#/definitions/Node",
|
|
1495
|
+
"description": "The tree node."
|
|
1496
|
+
},
|
|
1497
|
+
"physicalName": {
|
|
1498
|
+
"description": "Returns a string-encoded token that resolves to the physical name that\nshould be passed to the CloudFormation resource.\n\nThis value will resolve to one of the following:\n- a concrete value (e.g. `\"my-awesome-bucket\"`)\n- `undefined`, when a name should be generated by CloudFormation\n- a concrete name generated automatically during synthesis, in\n cross-environment scenarios.",
|
|
1499
|
+
"type": "string"
|
|
1500
|
+
},
|
|
1501
|
+
"ref": {
|
|
1502
|
+
"description": "The physical name of this custom resource.",
|
|
1503
|
+
"type": "string"
|
|
1504
|
+
},
|
|
1505
|
+
"resource": {},
|
|
1506
|
+
"stack": {
|
|
1507
|
+
"$ref": "#/definitions/Stack",
|
|
1508
|
+
"description": "The stack in which this resource is defined."
|
|
1509
|
+
}
|
|
1510
|
+
},
|
|
1511
|
+
"required": [
|
|
1512
|
+
"_allowCrossEnvironment",
|
|
1513
|
+
"_physicalName",
|
|
1514
|
+
"env",
|
|
1515
|
+
"handlerFunction",
|
|
1516
|
+
"node",
|
|
1517
|
+
"physicalName",
|
|
1518
|
+
"ref",
|
|
1519
|
+
"resource",
|
|
1520
|
+
"stack"
|
|
1521
|
+
],
|
|
1522
|
+
"type": "object"
|
|
1523
|
+
},
|
|
1524
|
+
"MdaaLambdaFunction": {
|
|
1525
|
+
"additionalProperties": false,
|
|
1526
|
+
"description": "Construct for creating a compliant Lambda Function",
|
|
1527
|
+
"properties": {
|
|
1528
|
+
"_allowCrossEnvironment": {},
|
|
1529
|
+
"_architecture": {},
|
|
1530
|
+
"_connections": {
|
|
1531
|
+
"$ref": "#/definitions/Connections",
|
|
1532
|
+
"description": "Actual connections object for this Lambda\n\nMay be unset, in which case this Lambda is not configured use in a VPC."
|
|
1533
|
+
},
|
|
1534
|
+
"_currentVersion": {},
|
|
1535
|
+
"_functionUrlInvocationGrants": {
|
|
1536
|
+
"$ref": "#/definitions/Record%3Cstring%2CGrant%3E",
|
|
1537
|
+
"description": "Mapping of function URL invocation principals to grants. Used to de-dupe `grantInvokeUrl()` calls."
|
|
1538
|
+
},
|
|
1539
|
+
"_hasAddedArrayTokenStatements": {
|
|
1540
|
+
"description": "Track whether we've added statements with array token resources to the role's default policy"
|
|
1541
|
+
},
|
|
1542
|
+
"_hasAddedLiteralStatements": {
|
|
1543
|
+
"description": "Track whether we've added statements with literal resources to the role's default policy"
|
|
1544
|
+
},
|
|
1545
|
+
"_invocationGrants": {
|
|
1546
|
+
"$ref": "#/definitions/Record%3Cstring%2CGrant%3E",
|
|
1547
|
+
"description": "Mapping of invocation principals to grants. Used to de-dupe `grantInvoke()` calls."
|
|
1548
|
+
},
|
|
1549
|
+
"_latestVersion": {},
|
|
1550
|
+
"_layers": {
|
|
1551
|
+
"items": {
|
|
1552
|
+
"$ref": "#/definitions/ILayerVersion"
|
|
1553
|
+
},
|
|
1554
|
+
"type": "array"
|
|
1555
|
+
},
|
|
1556
|
+
"_logGroup": {},
|
|
1557
|
+
"_logRetention": {
|
|
1558
|
+
"$ref": "#/definitions/LogRetention",
|
|
1559
|
+
"description": "Creates a custom resource to control the retention policy of a CloudWatch Logs\nlog group. The log group is created if it doesn't already exist. The policy\nis removed when `retentionDays` is `undefined` or equal to `Infinity`.\nLog group can be created in the region that is different from stack region by\nspecifying `logGroupRegion`"
|
|
1560
|
+
},
|
|
1561
|
+
"_physicalName": {},
|
|
1562
|
+
"_policyCounter": {
|
|
1563
|
+
"description": "The number of permissions added to this function"
|
|
1564
|
+
},
|
|
1565
|
+
"_skipPermissions": {
|
|
1566
|
+
"description": "Whether the user decides to skip adding permissions.\nThe only use case is for cross-account, imported lambdas\nwhere the user commits to modifying the permisssions\non the imported lambda outside CDK.",
|
|
1567
|
+
"type": "boolean"
|
|
1568
|
+
},
|
|
1569
|
+
"_warnIfCurrentVersionCalled": {
|
|
1570
|
+
"description": "Flag to delay adding a warning message until current version is invoked.",
|
|
1571
|
+
"type": "boolean"
|
|
1572
|
+
},
|
|
1573
|
+
"architecture": {
|
|
1574
|
+
"$ref": "#/definitions/Architecture",
|
|
1575
|
+
"description": "The architecture of this Lambda Function (this is an optional attribute and defaults to X86_64)."
|
|
1576
|
+
},
|
|
1577
|
+
"buildDeadLetterConfig": {},
|
|
1578
|
+
"buildDeadLetterQueue": {},
|
|
1579
|
+
"buildTracingConfig": {},
|
|
1580
|
+
"canCreatePermissions": {
|
|
1581
|
+
"const": true,
|
|
1582
|
+
"default": true,
|
|
1583
|
+
"description": "Whether the addPermission() call adds any permissions\n\nTrue for new Lambdas, false for version $LATEST and imported Lambdas\nfrom different accounts.",
|
|
1584
|
+
"type": "boolean"
|
|
1585
|
+
},
|
|
1586
|
+
"configureAdotInstrumentation": {
|
|
1587
|
+
"description": "Add an AWS Distro for OpenTelemetry Lambda layer."
|
|
1588
|
+
},
|
|
1589
|
+
"configureLambdaInsights": {
|
|
1590
|
+
"description": "Configured lambda insights on the function if specified. This is achieved by adding an imported layer which is added to the\nlist of lambda layers on synthesis.\n\nhttps://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Lambda-Insights-extension-versions.html"
|
|
1591
|
+
},
|
|
1592
|
+
"configureParamsAndSecretsExtension": {
|
|
1593
|
+
"description": "Add a Parameters and Secrets Extension Lambda layer."
|
|
1594
|
+
},
|
|
1595
|
+
"configureSnapStart": {},
|
|
1596
|
+
"configureVpc": {
|
|
1597
|
+
"description": "If configured, set up the VPC-related properties\n\nReturns the VpcConfig that should be added to the\nLambda creation properties."
|
|
1598
|
+
},
|
|
1599
|
+
"connections": {
|
|
1600
|
+
"$ref": "#/definitions/Connections",
|
|
1601
|
+
"description": "Access the Connections object\n\nWill fail if not a VPC-enabled Lambda Function"
|
|
1602
|
+
},
|
|
1603
|
+
"currentVersion": {
|
|
1604
|
+
"$ref": "#/definitions/Version",
|
|
1605
|
+
"description": "Returns a `lambda.Version` which represents the current version of this\nLambda function. A new version will be created every time the function's\nconfiguration changes.\n\nYou can specify options for this version using the `currentVersionOptions`\nprop when initializing the `lambda.Function`."
|
|
1606
|
+
},
|
|
1607
|
+
"currentVersionOptions": {},
|
|
1608
|
+
"deadLetterQueue": {
|
|
1609
|
+
"$ref": "#/definitions/IQueue",
|
|
1610
|
+
"description": "The DLQ (as queue) associated with this Lambda Function (this is an optional attribute)."
|
|
1611
|
+
},
|
|
1612
|
+
"deadLetterTopic": {
|
|
1613
|
+
"$ref": "#/definitions/ITopic",
|
|
1614
|
+
"description": "The DLQ (as topic) associated with this Lambda Function (this is an optional attribute)."
|
|
1615
|
+
},
|
|
1616
|
+
"env": {
|
|
1617
|
+
"$ref": "#/definitions/ResourceEnvironment",
|
|
1618
|
+
"description": "The environment this resource belongs to.\nFor resources that are created and managed by the CDK\n(generally, those created by creating new class instances like Role, Bucket, etc.),\nthis is always the same as the environment of the stack they belong to;\nhowever, for imported resources\n(those obtained from static methods like fromRoleArn, fromBucketName, etc.),\nthat might be different than the stack they were imported into."
|
|
1619
|
+
},
|
|
1620
|
+
"environment": {
|
|
1621
|
+
"description": "Environment variables for this function"
|
|
1622
|
+
},
|
|
1623
|
+
"functionArn": {
|
|
1624
|
+
"description": "ARN of this function",
|
|
1625
|
+
"type": "string"
|
|
1626
|
+
},
|
|
1627
|
+
"functionName": {
|
|
1628
|
+
"description": "Name of this function",
|
|
1629
|
+
"type": "string"
|
|
1630
|
+
},
|
|
1631
|
+
"functionRef": {
|
|
1632
|
+
"$ref": "#/definitions/FunctionReference",
|
|
1633
|
+
"description": "A reference to a Function resource."
|
|
1634
|
+
},
|
|
1635
|
+
"getLoggingConfig": {
|
|
1636
|
+
"description": "Get Logging Config property for the function.\nThis method returns the function LoggingConfig Property if the property is set on the\nfunction and undefined if not."
|
|
1637
|
+
},
|
|
1638
|
+
"grant": {},
|
|
1639
|
+
"grantPrincipal": {
|
|
1640
|
+
"$ref": "#/definitions/IPrincipal",
|
|
1641
|
+
"description": "The principal this Lambda Function is running as"
|
|
1642
|
+
},
|
|
1643
|
+
"hashMixins": {},
|
|
1644
|
+
"isBoundToVpc": {
|
|
1645
|
+
"description": "Whether or not this Lambda function was bound to a VPC\n\nIf this is is `false`, trying to access the `connections` object will fail.",
|
|
1646
|
+
"type": "boolean"
|
|
1647
|
+
},
|
|
1648
|
+
"isPrincipalWithConditions": {},
|
|
1649
|
+
"isQueue": {},
|
|
1650
|
+
"latestVersion": {
|
|
1651
|
+
"$ref": "#/definitions/IVersion",
|
|
1652
|
+
"description": "The `$LATEST` version of this function.\n\nNote that this is reference to a non-specific AWS Lambda version, which\nmeans the function this version refers to can return different results in\ndifferent invocations.\n\nTo obtain a reference to an explicit version which references the current\nfunction configuration, use `lambdaFunction.currentVersion` instead."
|
|
1653
|
+
},
|
|
1654
|
+
"logGroup": {
|
|
1655
|
+
"$ref": "#/definitions/ILogGroup",
|
|
1656
|
+
"description": "The LogGroup where the Lambda function's logs are made available.\n\nIf either `logRetention` is set or this property is called, a CloudFormation custom resource is added to the stack that\npre-creates the log group as part of the stack deployment, if it already doesn't exist, and sets the correct log retention\nperiod (never expire, by default).\n\nFurther, if the log group already exists and the `logRetention` is not set, the custom resource will reset the log retention\nto never expire even if it was configured with a different value."
|
|
1657
|
+
},
|
|
1658
|
+
"node": {
|
|
1659
|
+
"$ref": "#/definitions/Node",
|
|
1660
|
+
"description": "The tree node."
|
|
1661
|
+
},
|
|
1662
|
+
"parsePermissionPrincipal": {
|
|
1663
|
+
"description": "Translate IPrincipal to something we can pass to AWS::Lambda::Permissions\n\nDo some nasty things because `Permission` supports a subset of what the\nfull IAM principal language supports, and we may not be able to parse strings\noutright because they may be tokens.\n\nTry to recognize some specific Principal classes first, then try a generic\nfallback."
|
|
1664
|
+
},
|
|
1665
|
+
"permissionsNode": {
|
|
1666
|
+
"$ref": "#/definitions/Node",
|
|
1667
|
+
"description": "The construct node where permissions are attached."
|
|
1668
|
+
},
|
|
1669
|
+
"physicalName": {
|
|
1670
|
+
"description": "Returns a string-encoded token that resolves to the physical name that\nshould be passed to the CloudFormation resource.\n\nThis value will resolve to one of the following:\n- a concrete value (e.g. `\"my-awesome-bucket\"`)\n- `undefined`, when a name should be generated by CloudFormation\n- a concrete name generated automatically during synthesis, in\n cross-environment scenarios.",
|
|
1671
|
+
"type": "string"
|
|
1672
|
+
},
|
|
1673
|
+
"renderEnvironment": {},
|
|
1674
|
+
"renderLayers": {},
|
|
1675
|
+
"resourceArnsForGrantInvoke": {
|
|
1676
|
+
"description": "The ARN(s) to put into the resource field of the generated IAM policy for grantInvoke()",
|
|
1677
|
+
"items": {
|
|
1678
|
+
"type": "string"
|
|
1679
|
+
},
|
|
1680
|
+
"type": "array"
|
|
1681
|
+
},
|
|
1682
|
+
"role": {
|
|
1683
|
+
"$ref": "#/definitions/IRole",
|
|
1684
|
+
"description": "Execution role associated with this function"
|
|
1685
|
+
},
|
|
1686
|
+
"runtime": {
|
|
1687
|
+
"$ref": "#/definitions/Runtime",
|
|
1688
|
+
"description": "The runtime configured for this lambda."
|
|
1689
|
+
},
|
|
1690
|
+
"stack": {
|
|
1691
|
+
"$ref": "#/definitions/Stack",
|
|
1692
|
+
"description": "The stack in which this resource is defined."
|
|
1693
|
+
},
|
|
1694
|
+
"statementHasArrayTokens": {
|
|
1695
|
+
"description": "Check if a policy statement contains array tokens that would cause CloudFormation\nresolution conflicts when mixed with literal arrays in the same policy document.\n\nArray tokens are created by CloudFormation intrinsic functions that return arrays,\nsuch as Fn::Split, Fn::GetAZs, etc. These cannot be safely merged with literal\nresource arrays due to CloudFormation's token resolution limitations.\n\nIndividual string tokens within literal arrays (e.g., `[\"arn:${token}:...\"]`) are\nsafe and do not cause conflicts, so they are not detected by this method."
|
|
1696
|
+
},
|
|
1697
|
+
"timeout": {
|
|
1698
|
+
"$ref": "#/definitions/Duration",
|
|
1699
|
+
"description": "The timeout configured for this lambda."
|
|
1700
|
+
},
|
|
1701
|
+
"validateConditionCombinations": {},
|
|
1702
|
+
"validateConditions": {},
|
|
1703
|
+
"validateProfiling": {}
|
|
1704
|
+
},
|
|
1705
|
+
"required": [
|
|
1706
|
+
"_allowCrossEnvironment",
|
|
1707
|
+
"_functionUrlInvocationGrants",
|
|
1708
|
+
"_hasAddedArrayTokenStatements",
|
|
1709
|
+
"_hasAddedLiteralStatements",
|
|
1710
|
+
"_invocationGrants",
|
|
1711
|
+
"_layers",
|
|
1712
|
+
"_physicalName",
|
|
1713
|
+
"_policyCounter",
|
|
1714
|
+
"_warnIfCurrentVersionCalled",
|
|
1715
|
+
"architecture",
|
|
1716
|
+
"buildDeadLetterConfig",
|
|
1717
|
+
"buildDeadLetterQueue",
|
|
1718
|
+
"buildTracingConfig",
|
|
1719
|
+
"canCreatePermissions",
|
|
1720
|
+
"configureAdotInstrumentation",
|
|
1721
|
+
"configureLambdaInsights",
|
|
1722
|
+
"configureParamsAndSecretsExtension",
|
|
1723
|
+
"configureSnapStart",
|
|
1724
|
+
"configureVpc",
|
|
1725
|
+
"connections",
|
|
1726
|
+
"currentVersion",
|
|
1727
|
+
"env",
|
|
1728
|
+
"environment",
|
|
1729
|
+
"functionArn",
|
|
1730
|
+
"functionName",
|
|
1731
|
+
"functionRef",
|
|
1732
|
+
"getLoggingConfig",
|
|
1733
|
+
"grant",
|
|
1734
|
+
"grantPrincipal",
|
|
1735
|
+
"hashMixins",
|
|
1736
|
+
"isBoundToVpc",
|
|
1737
|
+
"isPrincipalWithConditions",
|
|
1738
|
+
"isQueue",
|
|
1739
|
+
"latestVersion",
|
|
1740
|
+
"logGroup",
|
|
1741
|
+
"node",
|
|
1742
|
+
"parsePermissionPrincipal",
|
|
1743
|
+
"permissionsNode",
|
|
1744
|
+
"physicalName",
|
|
1745
|
+
"renderEnvironment",
|
|
1746
|
+
"renderLayers",
|
|
1747
|
+
"resourceArnsForGrantInvoke",
|
|
1748
|
+
"runtime",
|
|
1749
|
+
"stack",
|
|
1750
|
+
"statementHasArrayTokens",
|
|
1751
|
+
"validateConditionCombinations",
|
|
1752
|
+
"validateConditions",
|
|
1753
|
+
"validateProfiling"
|
|
1754
|
+
],
|
|
1755
|
+
"type": "object"
|
|
1756
|
+
},
|
|
1757
|
+
"MdaaNagSuppressionByPath": {
|
|
1758
|
+
"additionalProperties": false,
|
|
1759
|
+
"properties": {
|
|
1760
|
+
"path": {
|
|
1761
|
+
"description": "CloudFormation resource path identifying the specific resource for which CDK Nag rules should be suppressed",
|
|
1762
|
+
"type": "string"
|
|
1763
|
+
},
|
|
1764
|
+
"suppressions": {
|
|
1765
|
+
"description": "Array of specific CDK Nag rule suppressions with rule IDs and mandatory justifications for audit compliance",
|
|
1766
|
+
"items": {
|
|
1767
|
+
"additionalProperties": false,
|
|
1768
|
+
"properties": {
|
|
1769
|
+
"id": {
|
|
1770
|
+
"type": "string"
|
|
1771
|
+
},
|
|
1772
|
+
"reason": {
|
|
1773
|
+
"type": "string"
|
|
1774
|
+
}
|
|
1775
|
+
},
|
|
1776
|
+
"required": [
|
|
1777
|
+
"id",
|
|
1778
|
+
"reason"
|
|
1779
|
+
],
|
|
1780
|
+
"type": "object"
|
|
1781
|
+
},
|
|
1782
|
+
"type": "array"
|
|
1783
|
+
}
|
|
1784
|
+
},
|
|
1785
|
+
"required": [
|
|
1786
|
+
"path",
|
|
1787
|
+
"suppressions"
|
|
1788
|
+
],
|
|
1789
|
+
"type": "object"
|
|
1790
|
+
},
|
|
1791
|
+
"MdaaNagSuppressionConfigs": {
|
|
1792
|
+
"additionalProperties": false,
|
|
1793
|
+
"properties": {
|
|
1794
|
+
"by_path": {
|
|
1795
|
+
"description": "Array of CDK Nag suppressions organized by CloudFormation resource path, enabling targeted",
|
|
1796
|
+
"items": {
|
|
1797
|
+
"$ref": "#/definitions/MdaaNagSuppressionByPath"
|
|
1798
|
+
},
|
|
1799
|
+
"type": "array"
|
|
1800
|
+
}
|
|
1801
|
+
},
|
|
1802
|
+
"required": [
|
|
1803
|
+
"by_path"
|
|
1804
|
+
],
|
|
1805
|
+
"type": "object"
|
|
1806
|
+
},
|
|
1807
|
+
"MdaaResourceNamingConfig": {
|
|
1808
|
+
"additionalProperties": false,
|
|
1809
|
+
"properties": {
|
|
1810
|
+
"cdkNode": {
|
|
1811
|
+
"$ref": "#/definitions/Node",
|
|
1812
|
+
"description": "CDK construct node providing access to context values for custom naming implementations"
|
|
1813
|
+
},
|
|
1814
|
+
"domain": {
|
|
1815
|
+
"description": "Domain identifier from MDAA configuration representing logical business or organizational boundaries",
|
|
1816
|
+
"type": "string"
|
|
1817
|
+
},
|
|
1818
|
+
"env": {
|
|
1819
|
+
"description": "Environment identifier from MDAA configuration that distinguishes deployment stages within the same domain",
|
|
1820
|
+
"type": "string"
|
|
1821
|
+
},
|
|
1822
|
+
"moduleName": {
|
|
1823
|
+
"description": "Module name from MDAA configuration identifying the specific MDAA module deployment within a domain/environment",
|
|
1824
|
+
"type": "string"
|
|
1825
|
+
},
|
|
1826
|
+
"org": {
|
|
1827
|
+
"description": "Organization identifier from MDAA configuration that serves as the top-level namespace for all AWS resource names",
|
|
1828
|
+
"type": "string"
|
|
1829
|
+
}
|
|
1830
|
+
},
|
|
1831
|
+
"required": [
|
|
1832
|
+
"cdkNode",
|
|
1833
|
+
"domain",
|
|
1834
|
+
"env",
|
|
1835
|
+
"moduleName",
|
|
1836
|
+
"org"
|
|
1837
|
+
],
|
|
1838
|
+
"type": "object"
|
|
1839
|
+
},
|
|
1840
|
+
"MdaaRoleRef": {
|
|
1841
|
+
"additionalProperties": false,
|
|
1842
|
+
"properties": {
|
|
1843
|
+
"arn": {
|
|
1844
|
+
"description": "Full IAM role ARN for cross-account role references and explicit role identification.\n\nUse cases: Cross-account role references; Explicit role binding; Multi-account deployments\n\nAWS: Full IAM role ARN (arn:aws:iam::ACCOUNT:role/ROLE-NAME)\n\nValidation: Optional; must be a valid IAM role ARN if provided",
|
|
1845
|
+
"type": "string"
|
|
1846
|
+
},
|
|
1847
|
+
"id": {
|
|
1848
|
+
"description": "IAM role unique identifier for role resolution using the role's AWS-generated ID.\n\nUse cases: Stable role references; Role resolution by unique ID; Immutable role binding\n\nAWS: IAM role unique ID (e.g., AROA...)\n\nValidation: Optional; must be a valid IAM role unique ID if provided",
|
|
1849
|
+
"type": "string"
|
|
1850
|
+
},
|
|
1851
|
+
"immutable": {
|
|
1852
|
+
"description": "Flag indicating whether the referenced role should be treated as immutable and not modified by MDAA operations.\n\nUse cases: Pre-existing role protection; Externally managed roles; Read-only role references\n\nAWS: Controls whether MDAA attaches policies or modifies the referenced IAM role\n\nValidation: Optional boolean; defaults to false",
|
|
1853
|
+
"type": "boolean"
|
|
1854
|
+
},
|
|
1855
|
+
"name": {
|
|
1856
|
+
"description": "IAM role name for role resolution within the same AWS account.\n\nUse cases: Same-account role references; Role name-based resolution; Local IAM role binding\n\nAWS: IAM role name resolved via GetRole within the deployment account\n\nValidation: Optional; must be a valid IAM role name; mutually preferred with arn/id for resolution",
|
|
1857
|
+
"type": "string"
|
|
1858
|
+
},
|
|
1859
|
+
"refId": {
|
|
1860
|
+
"description": "Unique identifier for the role reference within a configuration scope, enabling role lookup and deduplication.\n\nUse cases: Role reference identification; Configuration deduplication; Role lookup key\n\nAWS: Logical identifier for IAM role references within MDAA configuration\n\nValidation: Optional; must be unique within the configuration scope if provided",
|
|
1861
|
+
"type": "string"
|
|
1862
|
+
},
|
|
1863
|
+
"sso": {
|
|
1864
|
+
"description": "Flag indicating the role should be resolved as an AWS SSO auto-generated role.\n\nUse cases: AWS IAM Identity Center integration; SSO permission set role binding; Federated access\n\nAWS: Resolves role via AWS SSO/Identity Center auto-generated role naming convention\n\nValidation: Optional boolean; defaults to false",
|
|
1865
|
+
"type": "boolean"
|
|
1866
|
+
}
|
|
1867
|
+
},
|
|
1868
|
+
"type": "object"
|
|
1869
|
+
},
|
|
1870
|
+
"MdaaSageMakerBluePrintParameterConfig": {
|
|
1871
|
+
"additionalProperties": false,
|
|
1872
|
+
"properties": {
|
|
1873
|
+
"blueprintParamProps": {
|
|
1874
|
+
"$ref": "#/definitions/MdaaSageMakerBluePrintParameterProps"
|
|
1875
|
+
},
|
|
1876
|
+
"cfnParamProps": {
|
|
1877
|
+
"$ref": "#/definitions/CfnParameterProps"
|
|
1878
|
+
}
|
|
1879
|
+
},
|
|
1880
|
+
"required": [
|
|
1881
|
+
"blueprintParamProps"
|
|
1882
|
+
],
|
|
1883
|
+
"type": "object"
|
|
1884
|
+
},
|
|
1885
|
+
"MdaaSageMakerBluePrintParameterProps": {
|
|
1886
|
+
"additionalProperties": false,
|
|
1887
|
+
"properties": {
|
|
1888
|
+
"defaultValue": {
|
|
1889
|
+
"type": "string"
|
|
1890
|
+
},
|
|
1891
|
+
"description": {
|
|
1892
|
+
"type": "string"
|
|
1893
|
+
},
|
|
1894
|
+
"fieldType": {
|
|
1895
|
+
"type": "string"
|
|
1896
|
+
},
|
|
1897
|
+
"isEditable": {
|
|
1898
|
+
"type": "boolean"
|
|
1899
|
+
},
|
|
1900
|
+
"isOptional": {
|
|
1901
|
+
"type": "boolean"
|
|
1902
|
+
},
|
|
1903
|
+
"isUpdateSupported": {
|
|
1904
|
+
"type": "boolean"
|
|
1905
|
+
}
|
|
1906
|
+
},
|
|
1907
|
+
"required": [
|
|
1908
|
+
"fieldType"
|
|
1909
|
+
],
|
|
1910
|
+
"type": "object"
|
|
1911
|
+
},
|
|
1912
|
+
"MdaaSageMakerCustomBluePrintConfig": {
|
|
1913
|
+
"additionalProperties": false,
|
|
1914
|
+
"description": "Q-ENHANCED-INTERFACE\nConfiguration interface for AWS SageMaker blueprint deployment that specifies domain association, and parameterization. Enables MDAA modules to be deployed as self-service SageMaker blueprints with controlled access and validation.\n\nUse cases: Self-service infrastructure deployment; Controlled resource provisioning; Parameterized blueprint offerings\n\nAWS: Configures AWS SageMaker blueprints for self-service deployment of MDAA modules with domain management\n\nValidation: domain_arn must be valid SageMaker domain ARN;",
|
|
1915
|
+
"properties": {
|
|
1916
|
+
"additionalAccounts": {
|
|
1917
|
+
"additionalProperties": {
|
|
1918
|
+
"$ref": "#/definitions/AdditionalBlueprintAccount"
|
|
1919
|
+
},
|
|
1920
|
+
"description": "Q-ENHANCED-PROPERTY\nOptional map of additional AWS accounts where the SageMaker blueprint should be enabled. Each entry maps a friendly account name to account-specific configuration including provisioning role ARN and optional parameters and authorized domain units.\n\nUse cases: Multi-account deployment; Cross-account provisioning; Account-specific configuration\n\nAWS: AWS SageMaker blueprint multi-account provisioning configuration\n\nValidation: Must be object with string keys and valid account configuration values if provided",
|
|
1921
|
+
"type": "object"
|
|
1922
|
+
},
|
|
1923
|
+
"authorizedDomainUnits": {
|
|
1924
|
+
"items": {
|
|
1925
|
+
"type": "string"
|
|
1926
|
+
},
|
|
1927
|
+
"type": "array"
|
|
1928
|
+
},
|
|
1929
|
+
"blueprintName": {
|
|
1930
|
+
"type": "string"
|
|
1931
|
+
},
|
|
1932
|
+
"description": {
|
|
1933
|
+
"description": "Q-ENHANCED-PROPERTY\nDescription for the SageMaker blueprint that will be visible to end users in the SageMaker console. Should be descriptive and user-friendly to facilitate blueprint discovery and selection.\n\nUse cases: Product identification; User-friendly naming; SageMaker console display\n\nAWS: AWS SageMaker blueprint name for user interface display\n\nValidation: Must be non-empty string suitable for SageMaker blueprint naming",
|
|
1934
|
+
"type": "string"
|
|
1935
|
+
},
|
|
1936
|
+
"domainBucketName": {
|
|
1937
|
+
"type": "string"
|
|
1938
|
+
},
|
|
1939
|
+
"domainConfig": {
|
|
1940
|
+
"$ref": "#/definitions/DomainConfig"
|
|
1941
|
+
},
|
|
1942
|
+
"domainConfigSSMParam": {
|
|
1943
|
+
"description": "Q-ENHANCED-PROPERTY\nOptional SSM parameter reference for domain configuration enabling dynamic domain configuration management. Specifies the SSM parameter containing domain configuration data for flexible domain setup and configuration management.\n\nUse cases: Dynamic configuration; SSM parameter reference; Configuration management; Flexible setup\n\nAWS: AWS Systems Manager parameter for DataZone domain configuration reference\n\nValidation: Must be valid SSM parameter name if provided; parameter must contain valid domain configuration",
|
|
1944
|
+
"type": "string"
|
|
1945
|
+
},
|
|
1946
|
+
"enabledRegions": {
|
|
1947
|
+
"items": {
|
|
1948
|
+
"type": "string"
|
|
1949
|
+
},
|
|
1950
|
+
"type": "array"
|
|
1951
|
+
},
|
|
1952
|
+
"parameters": {
|
|
1953
|
+
"additionalProperties": {
|
|
1954
|
+
"$ref": "#/definitions/MdaaSageMakerBluePrintParameterConfig"
|
|
1955
|
+
},
|
|
1956
|
+
"description": "Q-ENHANCED-PROPERTY\nOptional object containing named parameter configurations for the SageMaker blueprint. Enables parameterized blueprint deployment with validation rules and user input constraints.\n\nUse cases: Product parameterization; User input collection; Deployment customization\n\nAWS: AWS SageMaker blueprint parameters for user-configurable deployment options\n\nValidation: Must be object with string keys and valid MdaaServiceCatalogParameterConfig values if provided\n *",
|
|
1957
|
+
"type": "object"
|
|
1958
|
+
},
|
|
1959
|
+
"provisioningRole": {
|
|
1960
|
+
"$ref": "#/definitions/MdaaRoleRef"
|
|
1961
|
+
}
|
|
1962
|
+
},
|
|
1963
|
+
"required": [
|
|
1964
|
+
"provisioningRole"
|
|
1965
|
+
],
|
|
1966
|
+
"type": "object"
|
|
1967
|
+
},
|
|
1968
|
+
"MdaaServiceCatalogConstraintConfig": {
|
|
1969
|
+
"additionalProperties": false,
|
|
1970
|
+
"properties": {
|
|
1971
|
+
"description": {
|
|
1972
|
+
"description": "Human-readable description explaining the purpose and scope of the Service Catalog constraint",
|
|
1973
|
+
"type": "string"
|
|
1974
|
+
},
|
|
1975
|
+
"rules": {
|
|
1976
|
+
"additionalProperties": {
|
|
1977
|
+
"$ref": "#/definitions/MdaaServiceCatalogConstraintRuleConfig"
|
|
1978
|
+
},
|
|
1979
|
+
"description": "Object containing named constraint rules that define the validation logic for Service Catalog product parameters",
|
|
1980
|
+
"type": "object"
|
|
1981
|
+
}
|
|
1982
|
+
},
|
|
1983
|
+
"required": [
|
|
1984
|
+
"description",
|
|
1985
|
+
"rules"
|
|
1986
|
+
],
|
|
1987
|
+
"type": "object"
|
|
1988
|
+
},
|
|
1989
|
+
"MdaaServiceCatalogConstraintRuleAssertionConfig": {
|
|
1990
|
+
"additionalProperties": false,
|
|
1991
|
+
"properties": {
|
|
1992
|
+
"assert": {
|
|
1993
|
+
"description": "Constraint assertion expression that defines the validation logic for Service Catalog product parameters",
|
|
1994
|
+
"type": "string"
|
|
1995
|
+
},
|
|
1996
|
+
"description": {
|
|
1997
|
+
"description": "Human-readable description explaining the purpose and requirements of the constraint assertion",
|
|
1998
|
+
"type": "string"
|
|
1999
|
+
}
|
|
2000
|
+
},
|
|
2001
|
+
"required": [
|
|
2002
|
+
"assert",
|
|
2003
|
+
"description"
|
|
2004
|
+
],
|
|
2005
|
+
"type": "object"
|
|
2006
|
+
},
|
|
2007
|
+
"MdaaServiceCatalogConstraintRuleCondititionConfig": {
|
|
2008
|
+
"additionalProperties": false,
|
|
2009
|
+
"type": "object"
|
|
2010
|
+
},
|
|
2011
|
+
"MdaaServiceCatalogConstraintRuleConfig": {
|
|
2012
|
+
"additionalProperties": false,
|
|
2013
|
+
"properties": {
|
|
2014
|
+
"assertions": {
|
|
2015
|
+
"description": "Array of constraint assertions that define the validation logic to be applied when the condition is met",
|
|
2016
|
+
"items": {
|
|
2017
|
+
"$ref": "#/definitions/MdaaServiceCatalogConstraintRuleAssertionConfig"
|
|
2018
|
+
},
|
|
2019
|
+
"type": "array"
|
|
2020
|
+
},
|
|
2021
|
+
"condition": {
|
|
2022
|
+
"$ref": "#/definitions/MdaaServiceCatalogConstraintRuleCondititionConfig",
|
|
2023
|
+
"description": "Condition configuration that determines when the constraint rule assertions should be evaluated"
|
|
2024
|
+
}
|
|
2025
|
+
},
|
|
2026
|
+
"required": [
|
|
2027
|
+
"assertions",
|
|
2028
|
+
"condition"
|
|
2029
|
+
],
|
|
2030
|
+
"type": "object"
|
|
2031
|
+
},
|
|
2032
|
+
"MdaaServiceCatalogParameterConfig": {
|
|
2033
|
+
"additionalProperties": false,
|
|
2034
|
+
"properties": {
|
|
2035
|
+
"constraints": {
|
|
2036
|
+
"$ref": "#/definitions/MdaaServiceCatalogConstraintConfig",
|
|
2037
|
+
"description": "Constraint configuration that defines additional validation rules for the Service Catalog product parameter"
|
|
2038
|
+
},
|
|
2039
|
+
"props": {
|
|
2040
|
+
"$ref": "#/definitions/CfnParameterProps",
|
|
2041
|
+
"description": "CloudFormation parameter properties that define the parameter characteristics including type,"
|
|
2042
|
+
}
|
|
2043
|
+
},
|
|
2044
|
+
"required": [
|
|
2045
|
+
"props"
|
|
2046
|
+
],
|
|
2047
|
+
"type": "object"
|
|
2048
|
+
},
|
|
2049
|
+
"MdaaServiceCatalogProductConfig": {
|
|
2050
|
+
"additionalProperties": false,
|
|
2051
|
+
"properties": {
|
|
2052
|
+
"launch_role_name": {
|
|
2053
|
+
"description": "IAM role name that will be used to launch the Service Catalog product",
|
|
2054
|
+
"type": "string"
|
|
2055
|
+
},
|
|
2056
|
+
"name": {
|
|
2057
|
+
"description": "Display name for the Service Catalog product that will be visible to end users in the Service Catalog console",
|
|
2058
|
+
"type": "string"
|
|
2059
|
+
},
|
|
2060
|
+
"owner": {
|
|
2061
|
+
"description": "Owner identifier for the Service Catalog product, typically representing the team or organization",
|
|
2062
|
+
"type": "string"
|
|
2063
|
+
},
|
|
2064
|
+
"parameters": {
|
|
2065
|
+
"additionalProperties": {
|
|
2066
|
+
"$ref": "#/definitions/MdaaServiceCatalogParameterConfig"
|
|
2067
|
+
},
|
|
2068
|
+
"description": "Object containing named parameter configurations for the Service Catalog product",
|
|
2069
|
+
"type": "object"
|
|
2070
|
+
},
|
|
2071
|
+
"portfolio_arn": {
|
|
2072
|
+
"description": "ARN of the AWS Service Catalog portfolio where the product will be associated",
|
|
2073
|
+
"type": "string"
|
|
2074
|
+
},
|
|
2075
|
+
"portfolio_bucket_name": {
|
|
2076
|
+
"type": "string"
|
|
2077
|
+
}
|
|
2078
|
+
},
|
|
2079
|
+
"required": [
|
|
2080
|
+
"name",
|
|
2081
|
+
"owner",
|
|
2082
|
+
"portfolio_arn",
|
|
2083
|
+
"portfolio_bucket_name"
|
|
2084
|
+
],
|
|
2085
|
+
"type": "object"
|
|
2086
|
+
},
|
|
2087
|
+
"MetadataEntry": {
|
|
2088
|
+
"additionalProperties": false,
|
|
2089
|
+
"description": "An entry in the construct metadata table.",
|
|
2090
|
+
"properties": {
|
|
2091
|
+
"data": {
|
|
2092
|
+
"description": "The data."
|
|
2093
|
+
},
|
|
2094
|
+
"trace": {
|
|
2095
|
+
"default": "- no trace information",
|
|
2096
|
+
"description": "Stack trace at the point of adding the metadata.\n\nOnly available if `addMetadata()` is called with `stackTrace: true`.",
|
|
2097
|
+
"items": {
|
|
2098
|
+
"type": "string"
|
|
2099
|
+
},
|
|
2100
|
+
"type": "array"
|
|
2101
|
+
},
|
|
2102
|
+
"type": {
|
|
2103
|
+
"description": "The metadata entry type.",
|
|
2104
|
+
"type": "string"
|
|
2105
|
+
}
|
|
2106
|
+
},
|
|
2107
|
+
"required": [
|
|
2108
|
+
"data",
|
|
2109
|
+
"type"
|
|
2110
|
+
],
|
|
2111
|
+
"type": "object"
|
|
2112
|
+
},
|
|
2113
|
+
"Node": {
|
|
2114
|
+
"additionalProperties": false,
|
|
2115
|
+
"description": "Represents the construct node in the scope tree.",
|
|
2116
|
+
"properties": {
|
|
2117
|
+
"_addr": {},
|
|
2118
|
+
"_children": {},
|
|
2119
|
+
"_context": {},
|
|
2120
|
+
"_defaultChild": {},
|
|
2121
|
+
"_dependencies": {},
|
|
2122
|
+
"_locked": {},
|
|
2123
|
+
"_metadata": {},
|
|
2124
|
+
"_validations": {},
|
|
2125
|
+
"addChild": {
|
|
2126
|
+
"description": "Adds a child construct to this node."
|
|
2127
|
+
},
|
|
2128
|
+
"addr": {
|
|
2129
|
+
"description": "Returns an opaque tree-unique address for this construct.\n\nAddresses are 42 characters hexadecimal strings. They begin with \"c8\"\nfollowed by 40 lowercase hexadecimal characters (0-9a-f).\n\nAddresses are calculated using a SHA-1 of the components of the construct\npath.\n\nTo enable refactorings of construct trees, constructs with the ID `Default`\nwill be excluded from the calculation. In those cases constructs in the\nsame tree may have the same addreess.",
|
|
2130
|
+
"type": "string"
|
|
2131
|
+
},
|
|
2132
|
+
"children": {
|
|
2133
|
+
"description": "All direct children of this construct.",
|
|
2134
|
+
"items": {
|
|
2135
|
+
"$ref": "#/definitions/IConstruct"
|
|
2136
|
+
},
|
|
2137
|
+
"type": "array"
|
|
2138
|
+
},
|
|
2139
|
+
"defaultChild": {
|
|
2140
|
+
"$ref": "#/definitions/IConstruct",
|
|
2141
|
+
"description": "Returns the child construct that has the id `Default` or `Resource\"`.\nThis is usually the construct that provides the bulk of the underlying functionality.\nUseful for modifications of the underlying construct that are not available at the higher levels.\nOverride the defaultChild property.\n\nThis should only be used in the cases where the correct\ndefault child is not named 'Resource' or 'Default' as it\nshould be.\n\nIf you set this to undefined, the default behavior of finding\nthe child named 'Resource' or 'Default' will be used."
|
|
2142
|
+
},
|
|
2143
|
+
"dependencies": {
|
|
2144
|
+
"description": "Return all dependencies registered on this node (non-recursive).",
|
|
2145
|
+
"items": {
|
|
2146
|
+
"$ref": "#/definitions/IConstruct"
|
|
2147
|
+
},
|
|
2148
|
+
"type": "array"
|
|
2149
|
+
},
|
|
2150
|
+
"host": {},
|
|
2151
|
+
"id": {
|
|
2152
|
+
"description": "The id of this construct within the current scope.\n\nThis is a a scope-unique id. To obtain an app-unique id for this construct, use `addr`.",
|
|
2153
|
+
"type": "string"
|
|
2154
|
+
},
|
|
2155
|
+
"locked": {
|
|
2156
|
+
"description": "Returns true if this construct or the scopes in which it is defined are\nlocked.",
|
|
2157
|
+
"type": "boolean"
|
|
2158
|
+
},
|
|
2159
|
+
"metadata": {
|
|
2160
|
+
"description": "An immutable array of metadata objects associated with this construct.\nThis can be used, for example, to implement support for deprecation notices, source mapping, etc.",
|
|
2161
|
+
"items": {
|
|
2162
|
+
"$ref": "#/definitions/MetadataEntry"
|
|
2163
|
+
},
|
|
2164
|
+
"type": "array"
|
|
2165
|
+
},
|
|
2166
|
+
"path": {
|
|
2167
|
+
"description": "The full, absolute path of this construct in the tree.\n\nComponents are separated by '/'.",
|
|
2168
|
+
"type": "string"
|
|
2169
|
+
},
|
|
2170
|
+
"root": {
|
|
2171
|
+
"$ref": "#/definitions/IConstruct",
|
|
2172
|
+
"description": "Returns the root of the construct tree."
|
|
2173
|
+
},
|
|
2174
|
+
"scope": {
|
|
2175
|
+
"$ref": "#/definitions/IConstruct",
|
|
2176
|
+
"description": "Returns the scope in which this construct is defined.\n\nThe value is `undefined` at the root of the construct scope tree."
|
|
2177
|
+
},
|
|
2178
|
+
"scopes": {
|
|
2179
|
+
"description": "All parent scopes of this construct.",
|
|
2180
|
+
"items": {
|
|
2181
|
+
"$ref": "#/definitions/IConstruct"
|
|
2182
|
+
},
|
|
2183
|
+
"type": "array"
|
|
2184
|
+
}
|
|
2185
|
+
},
|
|
2186
|
+
"required": [
|
|
2187
|
+
"_children",
|
|
2188
|
+
"_context",
|
|
2189
|
+
"_defaultChild",
|
|
2190
|
+
"_dependencies",
|
|
2191
|
+
"_locked",
|
|
2192
|
+
"_metadata",
|
|
2193
|
+
"_validations",
|
|
2194
|
+
"addChild",
|
|
2195
|
+
"addr",
|
|
2196
|
+
"children",
|
|
2197
|
+
"dependencies",
|
|
2198
|
+
"host",
|
|
2199
|
+
"id",
|
|
2200
|
+
"locked",
|
|
2201
|
+
"metadata",
|
|
2202
|
+
"path",
|
|
2203
|
+
"root",
|
|
2204
|
+
"scopes"
|
|
2205
|
+
],
|
|
2206
|
+
"type": "object"
|
|
2207
|
+
},
|
|
2208
|
+
"PipelineConfig": {
|
|
2209
|
+
"additionalProperties": false,
|
|
2210
|
+
"description": "Q-ENHANCED-INTERFACE\nIndividual pipeline configuration interface for environment-specific MDAA deployment pipelines with domain, environment, and module filtering capabilities. Defines pipeline-specific deployment parameters including target filters for selective deployment, custom command execution, and pipeline-level deployment lifecycle management for targeted infrastructure deployment within multi-domain data architectures.\nUse cases: Environment-specific pipelines; Selective module deployment; Domain-filtered deployments; Pipeline customization; Targeted infrastructure updates\nAWS: AWS CodePipeline configuration with domain/environment/module filtering for selective MDAA deployment targeting specific infrastructure components\nValidation: domainFilter, envFilter, and moduleFilter must reference valid MDAA domains, environments, and modules; pipeline must inherit valid Commands configuration",
|
|
2211
|
+
"properties": {
|
|
2212
|
+
"deploy": {
|
|
2213
|
+
"$ref": "#/definitions/StageCommands",
|
|
2214
|
+
"description": "Q-ENHANCED-INTERFACE\nDeployment stage command configuration interface for CodeBuild projects that execute custom scripts during MDAA deployment pipeline stages. Defines install dependencies, pre-deployment preparation commands, and post-deployment cleanup commands that run in CodeBuild environments to customize deployment behavior and perform environment-specific operations.\n\nUse cases: Environment preparation; Custom deployment scripts; Post-deployment cleanup; Infrastructure customization; Environment-specific configuration\n\nAWS: AWS CodeBuild project commands with install, pre-execution, and post-execution hooks for deployment stage customization\n\nValidation: install commands must be valid package manager commands; pre/post commands must be executable shell scripts; commands execute in CodeBuild Linux environment"
|
|
2215
|
+
},
|
|
2216
|
+
"domainFilter": {
|
|
2217
|
+
"description": "Q-ENHANCED-PROPERTY\nOptional array of domain names for pipeline deployment filtering enabling selective domain-specific deployments. Restricts pipeline execution to only the specified MDAA domains, allowing for targeted deployment strategies and domain isolation in multi-domain data architectures.\n\nUse cases: Domain-specific deployments; Multi-domain filtering; Selective domain updates; Domain isolation strategies\n\nAWS: AWS CodePipeline domain filtering for selective MDAA domain deployment and targeted infrastructure updates\n\nValidation: Must be array of valid MDAA domain names if provided; domains must exist in MDAA configuration; optional for domain filtering",
|
|
2218
|
+
"items": {
|
|
2219
|
+
"type": "string"
|
|
2220
|
+
},
|
|
2221
|
+
"type": "array"
|
|
2222
|
+
},
|
|
2223
|
+
"envFilter": {
|
|
2224
|
+
"description": "Q-ENHANCED-PROPERTY\nOptional array of environment names for pipeline deployment filtering enabling selective environment-specific deployments. Restricts pipeline execution to only the specified MDAA environments, allowing for targeted deployment strategies and environment isolation across development, staging, and production environments.\n\nUse cases: Environment-specific deployments; Multi-environment filtering; Selective environment updates; Environment isolation strategies\n\nAWS: AWS CodePipeline environment filtering for selective MDAA environment deployment and targeted infrastructure updates\n\nValidation: Must be array of valid MDAA environment names if provided; environments must exist in MDAA configuration; optional for environment filtering",
|
|
2225
|
+
"items": {
|
|
2226
|
+
"type": "string"
|
|
2227
|
+
},
|
|
2228
|
+
"type": "array"
|
|
2229
|
+
},
|
|
2230
|
+
"install": {
|
|
2231
|
+
"description": "Q-ENHANCED-PROPERTY\nOptional array of package installation commands for CodeBuild environment setup enabling dependency management and tool installation. Defines commands that will be executed during the install phase to install required packages, dependencies, and tools needed for deployment operations.\n\nUse cases: Dependency installation; Tool setup; Package management; Environment preparation; Build tool installation\n\nAWS: AWS CodeBuild install phase commands for dependency installation and environment setup\n\nValidation: Must be array of valid shell commands if provided; commands execute in CodeBuild Linux environment; optional for install phase",
|
|
2232
|
+
"items": {
|
|
2233
|
+
"type": "string"
|
|
2234
|
+
},
|
|
2235
|
+
"type": "array"
|
|
2236
|
+
},
|
|
2237
|
+
"moduleFilter": {
|
|
2238
|
+
"description": "Q-ENHANCED-PROPERTY\nOptional array of module names for pipeline deployment filtering enabling selective module-specific deployments. Restricts pipeline execution to only the specified MDAA modules, allowing for targeted deployment strategies and module isolation for specific infrastructure components or services.\n\nUse cases: Module-specific deployments; Multi-module filtering; Selective module updates; Component isolation strategies\n\nAWS: AWS CodePipeline module filtering for selective MDAA module deployment and targeted infrastructure component updates\n\nValidation: Must be array of valid MDAA module names if provided; modules must exist in MDAA configuration; optional for module filtering",
|
|
2239
|
+
"items": {
|
|
2240
|
+
"type": "string"
|
|
2241
|
+
},
|
|
2242
|
+
"type": "array"
|
|
2243
|
+
},
|
|
2244
|
+
"post": {
|
|
2245
|
+
"description": "Q-ENHANCED-PROPERTY\nOptional array of post-execution commands for deployment stage cleanup and finalization enabling custom cleanup and post-deployment operations. Defines commands that will be executed after the main deployment stage to perform cleanup, notification, validation, and finalization tasks.\n\nUse cases: Post-deployment cleanup; Notification sending; Validation checks; Resource cleanup; Finalization tasks\n\nAWS: AWS CodeBuild post-execution commands for deployment stage cleanup and finalization\n\nValidation: Must be array of valid shell commands if provided; commands execute in CodeBuild Linux environment; optional for post-execution phase",
|
|
2246
|
+
"items": {
|
|
2247
|
+
"type": "string"
|
|
2248
|
+
},
|
|
2249
|
+
"type": "array"
|
|
2250
|
+
},
|
|
2251
|
+
"postDeployValidate": {
|
|
2252
|
+
"$ref": "#/definitions/ValidateStageCommands",
|
|
2253
|
+
"description": "Q-ENHANCED-INTERFACE\nValidation stage command configuration interface for CodeBuild validation projects that execute infrastructure testing and compliance verification during MDAA deployment pipelines. Defines install dependencies and validation commands that run in CodeBuild environments to verify deployed infrastructure meets requirements before pipeline progression.\n\nUse cases: Infrastructure smoke testing; Compliance verification; Deployment validation; Quality gate enforcement; Post-deployment verification\n\nAWS: AWS CodeBuild validation project commands with install dependencies and validation script execution for pipeline quality gates\n\nValidation: install commands must be valid package manager commands; commands must be executable shell scripts that return appropriate exit codes for pipeline success/failure"
|
|
2254
|
+
},
|
|
2255
|
+
"pre": {
|
|
2256
|
+
"description": "Q-ENHANCED-PROPERTY\nOptional array of pre-execution commands for deployment stage preparation enabling custom setup and validation before main deployment operations. Defines commands that will be executed before the main deployment stage to perform environment preparation, validation, and custom setup tasks.\n\nUse cases: Environment preparation; Pre-deployment validation; Custom setup; Configuration verification; Prerequisite checks\n\nAWS: AWS CodeBuild pre-execution commands for deployment stage preparation and validation\n\nValidation: Must be array of valid shell commands if provided; commands execute in CodeBuild Linux environment; optional for pre-execution phase",
|
|
2257
|
+
"items": {
|
|
2258
|
+
"type": "string"
|
|
93
2259
|
},
|
|
94
2260
|
"type": "array"
|
|
2261
|
+
},
|
|
2262
|
+
"preDeploy": {
|
|
2263
|
+
"$ref": "#/definitions/StageCommands",
|
|
2264
|
+
"description": "Q-ENHANCED-INTERFACE\nDeployment stage command configuration interface for CodeBuild projects that execute custom scripts during MDAA deployment pipeline stages. Defines install dependencies, pre-deployment preparation commands, and post-deployment cleanup commands that run in CodeBuild environments to customize deployment behavior and perform environment-specific operations.\n\nUse cases: Environment preparation; Custom deployment scripts; Post-deployment cleanup; Infrastructure customization; Environment-specific configuration\n\nAWS: AWS CodeBuild project commands with install, pre-execution, and post-execution hooks for deployment stage customization\n\nValidation: install commands must be valid package manager commands; pre/post commands must be executable shell scripts; commands execute in CodeBuild Linux environment"
|
|
2265
|
+
},
|
|
2266
|
+
"preDeployValidate": {
|
|
2267
|
+
"$ref": "#/definitions/ValidateStageCommands",
|
|
2268
|
+
"description": "Q-ENHANCED-INTERFACE\nValidation stage command configuration interface for CodeBuild validation projects that execute infrastructure testing and compliance verification during MDAA deployment pipelines. Defines install dependencies and validation commands that run in CodeBuild environments to verify deployed infrastructure meets requirements before pipeline progression.\n\nUse cases: Infrastructure smoke testing; Compliance verification; Deployment validation; Quality gate enforcement; Post-deployment verification\n\nAWS: AWS CodeBuild validation project commands with install dependencies and validation script execution for pipeline quality gates\n\nValidation: install commands must be valid package manager commands; commands must be executable shell scripts that return appropriate exit codes for pipeline success/failure"
|
|
95
2269
|
}
|
|
96
2270
|
},
|
|
97
|
-
"required": [
|
|
98
|
-
"path",
|
|
99
|
-
"suppressions"
|
|
100
|
-
],
|
|
101
2271
|
"type": "object"
|
|
102
2272
|
},
|
|
103
|
-
"
|
|
2273
|
+
"Port": {
|
|
104
2274
|
"additionalProperties": false,
|
|
105
|
-
"description": "
|
|
2275
|
+
"description": "Interface for classes that provide the connection-specification parts of a security group rule",
|
|
106
2276
|
"properties": {
|
|
107
|
-
"
|
|
108
|
-
"description": "
|
|
109
|
-
"
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
"type": "array"
|
|
113
|
-
}
|
|
2277
|
+
"canInlineRule": {
|
|
2278
|
+
"description": "Whether the rule containing this port range can be inlined into a securitygroup or not.",
|
|
2279
|
+
"type": "boolean"
|
|
2280
|
+
},
|
|
2281
|
+
"props": {}
|
|
114
2282
|
},
|
|
115
2283
|
"required": [
|
|
116
|
-
"
|
|
2284
|
+
"canInlineRule",
|
|
2285
|
+
"props"
|
|
117
2286
|
],
|
|
118
2287
|
"type": "object"
|
|
119
2288
|
},
|
|
120
|
-
"
|
|
2289
|
+
"PrincipalPolicyFragment": {
|
|
121
2290
|
"additionalProperties": false,
|
|
122
|
-
"description": "
|
|
2291
|
+
"description": "A collection of the fields in a PolicyStatement that can be used to identify a principal.\n\nThis consists of the JSON used in the \"Principal\" field, and optionally a\nset of \"Condition\"s that need to be applied to the policy.\n\nGenerally, a principal looks like:\n\n { '<TYPE>': ['ID', 'ID', ...] }\n\nAnd this is also the type of the field `principalJson`. However, there is a\nspecial type of principal that is just the string '*', which is treated\ndifferently by some services. To represent that principal, `principalJson`\nshould contain `{ 'LiteralString': ['*'] }`.",
|
|
123
2292
|
"properties": {
|
|
124
|
-
"
|
|
125
|
-
"
|
|
126
|
-
"
|
|
2293
|
+
"conditions": {
|
|
2294
|
+
"$ref": "#/definitions/Conditions",
|
|
2295
|
+
"description": "The conditions under which the policy is in effect.\nSee [the IAM documentation](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_condition.html)."
|
|
127
2296
|
},
|
|
128
|
-
"
|
|
2297
|
+
"principalJson": {
|
|
129
2298
|
"additionalProperties": {
|
|
130
|
-
"
|
|
2299
|
+
"items": {
|
|
2300
|
+
"type": "string"
|
|
2301
|
+
},
|
|
2302
|
+
"type": "array"
|
|
131
2303
|
},
|
|
132
|
-
"description": "Q-ENHANCED-PROPERTY\nObject containing named constraint rules that define the validation logic for Service Catalog product parameters. Each rule can contain conditions and assertions for parameter validation.\n\nUse cases: Named validation rules; Organized constraint logic; Multiple validation scenarios\n\nAWS: AWS Service Catalog constraint rules for structured parameter validation\n\nValidation: Must be object with string keys and valid MdaaServiceCatalogConstraintRuleConfig values\n *",
|
|
133
2304
|
"type": "object"
|
|
134
2305
|
}
|
|
135
2306
|
},
|
|
136
2307
|
"required": [
|
|
137
|
-
"
|
|
138
|
-
"
|
|
2308
|
+
"conditions",
|
|
2309
|
+
"principalJson"
|
|
139
2310
|
],
|
|
140
2311
|
"type": "object"
|
|
141
2312
|
},
|
|
142
|
-
"
|
|
2313
|
+
"Record<string,Grant>": {
|
|
143
2314
|
"additionalProperties": false,
|
|
144
|
-
"
|
|
2315
|
+
"type": "object"
|
|
2316
|
+
},
|
|
2317
|
+
"ResourceEnvironment": {
|
|
2318
|
+
"additionalProperties": false,
|
|
2319
|
+
"description": "Represents the environment a given resource lives in.\nUsed as the return value for the `IResource.env` property.",
|
|
145
2320
|
"properties": {
|
|
146
|
-
"
|
|
147
|
-
"description": "
|
|
2321
|
+
"account": {
|
|
2322
|
+
"description": "The AWS account ID that this resource belongs to.\nSince this can be a Token\n(for example, when the account is CloudFormation's AWS::AccountId intrinsic),\nmake sure to use Token.compareStrings()\ninstead of just comparing the values for equality.",
|
|
148
2323
|
"type": "string"
|
|
149
2324
|
},
|
|
150
|
-
"
|
|
151
|
-
"description": "
|
|
2325
|
+
"region": {
|
|
2326
|
+
"description": "The AWS region that this resource belongs to.\nSince this can be a Token\n(for example, when the region is CloudFormation's AWS::Region intrinsic),\nmake sure to use Token.compareStrings()\ninstead of just comparing the values for equality.",
|
|
152
2327
|
"type": "string"
|
|
153
2328
|
}
|
|
154
2329
|
},
|
|
155
2330
|
"required": [
|
|
156
|
-
"
|
|
157
|
-
"
|
|
2331
|
+
"account",
|
|
2332
|
+
"region"
|
|
158
2333
|
],
|
|
159
2334
|
"type": "object"
|
|
160
2335
|
},
|
|
161
|
-
"
|
|
162
|
-
"additionalProperties": false,
|
|
163
|
-
"type": "object"
|
|
164
|
-
},
|
|
165
|
-
"MdaaServiceCatalogConstraintRuleConfig": {
|
|
2336
|
+
"RoleReference": {
|
|
166
2337
|
"additionalProperties": false,
|
|
167
|
-
"description": "
|
|
2338
|
+
"description": "A reference to a Role resource.",
|
|
168
2339
|
"properties": {
|
|
169
|
-
"
|
|
170
|
-
"description": "
|
|
171
|
-
"
|
|
172
|
-
"$ref": "#/definitions/MdaaServiceCatalogConstraintRuleAssertionConfig"
|
|
173
|
-
},
|
|
174
|
-
"type": "array"
|
|
2340
|
+
"roleArn": {
|
|
2341
|
+
"description": "The ARN of the Role resource.",
|
|
2342
|
+
"type": "string"
|
|
175
2343
|
},
|
|
176
|
-
"
|
|
177
|
-
"
|
|
178
|
-
"
|
|
2344
|
+
"roleName": {
|
|
2345
|
+
"description": "The RoleName of the Role resource.",
|
|
2346
|
+
"type": "string"
|
|
179
2347
|
}
|
|
180
2348
|
},
|
|
181
2349
|
"required": [
|
|
182
|
-
"
|
|
183
|
-
"
|
|
2350
|
+
"roleArn",
|
|
2351
|
+
"roleName"
|
|
184
2352
|
],
|
|
185
2353
|
"type": "object"
|
|
186
2354
|
},
|
|
187
|
-
"
|
|
2355
|
+
"Runtime": {
|
|
188
2356
|
"additionalProperties": false,
|
|
189
|
-
"description": "
|
|
2357
|
+
"description": "Lambda function runtime environment.\n\nIf you need to use a runtime name that doesn't exist as a static member, you\ncan instantiate a `Runtime` object, e.g: `new Runtime('nodejs99.99')`.",
|
|
190
2358
|
"properties": {
|
|
191
|
-
"
|
|
192
|
-
"$ref": "#/definitions/
|
|
193
|
-
"description": "
|
|
2359
|
+
"bundlingImage": {
|
|
2360
|
+
"$ref": "#/definitions/DockerImage",
|
|
2361
|
+
"description": "The bundling Docker image for this runtime."
|
|
194
2362
|
},
|
|
195
|
-
"
|
|
196
|
-
"
|
|
197
|
-
"
|
|
2363
|
+
"family": {
|
|
2364
|
+
"description": "The runtime family.",
|
|
2365
|
+
"enum": [
|
|
2366
|
+
0,
|
|
2367
|
+
1,
|
|
2368
|
+
2,
|
|
2369
|
+
3,
|
|
2370
|
+
4,
|
|
2371
|
+
5,
|
|
2372
|
+
6
|
|
2373
|
+
],
|
|
2374
|
+
"type": "number"
|
|
2375
|
+
},
|
|
2376
|
+
"isVariable": {
|
|
2377
|
+
"description": "Enabled for runtime enums that always target the latest available.",
|
|
2378
|
+
"type": "boolean"
|
|
2379
|
+
},
|
|
2380
|
+
"name": {
|
|
2381
|
+
"description": "The name of this runtime, as expected by the Lambda resource.",
|
|
2382
|
+
"type": "string"
|
|
2383
|
+
},
|
|
2384
|
+
"supportsCodeGuruProfiling": {
|
|
2385
|
+
"description": "Whether this runtime is integrated with and supported for profiling using Amazon CodeGuru Profiler.",
|
|
2386
|
+
"type": "boolean"
|
|
2387
|
+
},
|
|
2388
|
+
"supportsInlineCode": {
|
|
2389
|
+
"description": "Whether the ``ZipFile`` (aka inline code) property can be used with this\nruntime.",
|
|
2390
|
+
"type": "boolean"
|
|
2391
|
+
},
|
|
2392
|
+
"supportsSnapStart": {
|
|
2393
|
+
"description": "Whether this runtime supports snapstart.",
|
|
2394
|
+
"type": "boolean"
|
|
198
2395
|
}
|
|
199
2396
|
},
|
|
200
2397
|
"required": [
|
|
201
|
-
"
|
|
2398
|
+
"bundlingImage",
|
|
2399
|
+
"isVariable",
|
|
2400
|
+
"name",
|
|
2401
|
+
"supportsCodeGuruProfiling",
|
|
2402
|
+
"supportsInlineCode",
|
|
2403
|
+
"supportsSnapStart"
|
|
202
2404
|
],
|
|
203
2405
|
"type": "object"
|
|
204
2406
|
},
|
|
205
|
-
"
|
|
2407
|
+
"SecurityGroupReference": {
|
|
206
2408
|
"additionalProperties": false,
|
|
207
|
-
"description": "
|
|
2409
|
+
"description": "A reference to a SecurityGroup resource.",
|
|
208
2410
|
"properties": {
|
|
209
|
-
"
|
|
210
|
-
"description": "
|
|
211
|
-
"type": "string"
|
|
212
|
-
},
|
|
213
|
-
"name": {
|
|
214
|
-
"description": "Q-ENHANCED-PROPERTY\nDisplay name for the Service Catalog product that will be visible to end users in the Service Catalog console. Should be descriptive and user-friendly to facilitate product discovery and selection.\n\nUse cases: Product identification; User-friendly naming; Service Catalog console display\n\nAWS: AWS Service Catalog product name for user interface display\n\nValidation: Must be non-empty string suitable for Service Catalog product naming",
|
|
215
|
-
"type": "string"
|
|
216
|
-
},
|
|
217
|
-
"owner": {
|
|
218
|
-
"description": "Q-ENHANCED-PROPERTY\nOwner identifier for the Service Catalog product, typically representing the team or organization responsible for the product. Provides accountability and contact information for product management.\n\nUse cases: Product ownership identification; Contact information; Responsibility assignment\n\nAWS: AWS Service Catalog product owner for accountability and management\n\nValidation: Must be non-empty string identifying the product owner",
|
|
219
|
-
"type": "string"
|
|
220
|
-
},
|
|
221
|
-
"parameters": {
|
|
222
|
-
"additionalProperties": {
|
|
223
|
-
"$ref": "#/definitions/MdaaServiceCatalogParameterConfig"
|
|
224
|
-
},
|
|
225
|
-
"description": "Q-ENHANCED-PROPERTY\nOptional object containing named parameter configurations for the Service Catalog product. Enables parameterized product deployment with validation rules and user input constraints.\n\nUse cases: Product parameterization; User input collection; Deployment customization\n\nAWS: AWS Service Catalog product parameters for user-configurable deployment options\n\nValidation: Must be object with string keys and valid MdaaServiceCatalogParameterConfig values if provided\n *",
|
|
226
|
-
"type": "object"
|
|
227
|
-
},
|
|
228
|
-
"portfolio_arn": {
|
|
229
|
-
"description": "Q-ENHANCED-PROPERTY\nARN of the AWS Service Catalog portfolio where the product will be associated. Determines access control and organizational structure for the Service Catalog product deployment.\n\nUse cases: Portfolio organization; Access control; Product categorization\n\nAWS: AWS Service Catalog portfolio ARN for product association and access management\n\nValidation: Must be valid AWS Service Catalog portfolio ARN format",
|
|
2411
|
+
"securityGroupId": {
|
|
2412
|
+
"description": "The Id of the SecurityGroup resource.",
|
|
230
2413
|
"type": "string"
|
|
231
2414
|
}
|
|
232
2415
|
},
|
|
233
2416
|
"required": [
|
|
234
|
-
"
|
|
235
|
-
"owner",
|
|
236
|
-
"portfolio_arn"
|
|
2417
|
+
"securityGroupId"
|
|
237
2418
|
],
|
|
238
2419
|
"type": "object"
|
|
239
2420
|
},
|
|
240
|
-
"
|
|
2421
|
+
"Stack": {
|
|
241
2422
|
"additionalProperties": false,
|
|
242
|
-
"description": "
|
|
2423
|
+
"description": "A root construct which represents a single CloudFormation stack.",
|
|
243
2424
|
"properties": {
|
|
244
|
-
"
|
|
245
|
-
"
|
|
246
|
-
"
|
|
2425
|
+
"_crossRegionReferences": {
|
|
2426
|
+
"description": "Whether cross region references are enabled for this stack",
|
|
2427
|
+
"type": "boolean"
|
|
247
2428
|
},
|
|
248
|
-
"
|
|
249
|
-
"description": "
|
|
250
|
-
"items": {
|
|
251
|
-
"type": "string"
|
|
252
|
-
},
|
|
253
|
-
"type": "array"
|
|
2429
|
+
"_logicalIds": {
|
|
2430
|
+
"description": "Logical ID generation strategy"
|
|
254
2431
|
},
|
|
255
|
-
"
|
|
256
|
-
"description": "
|
|
257
|
-
"items": {
|
|
258
|
-
"type": "string"
|
|
259
|
-
},
|
|
260
|
-
"type": "array"
|
|
2432
|
+
"_missingContext": {
|
|
2433
|
+
"description": "Lists all missing contextual information.\nThis is returned when the stack is synthesized under the 'missing' attribute\nand allows tooling to obtain the context and re-synthesize."
|
|
261
2434
|
},
|
|
262
|
-
"
|
|
263
|
-
"description": "
|
|
2435
|
+
"_notificationArns": {
|
|
2436
|
+
"description": "SNS Notification ARNs to receive stack events.",
|
|
264
2437
|
"items": {
|
|
265
2438
|
"type": "string"
|
|
266
2439
|
},
|
|
267
2440
|
"type": "array"
|
|
268
2441
|
},
|
|
269
|
-
"
|
|
270
|
-
"description": "
|
|
2442
|
+
"_stackDependencies": {
|
|
2443
|
+
"description": "Other stacks this stack depends on"
|
|
2444
|
+
},
|
|
2445
|
+
"_stackName": {},
|
|
2446
|
+
"_suppressTemplateIndentation": {
|
|
2447
|
+
"default": "- the value of `@aws-cdk/core:suppressTemplateIndentation`, or `false` if that is not set.",
|
|
2448
|
+
"description": "Enable this flag to suppress indentation in generated\nCloudFormation templates.\n\nIf not specified, the value of the `@aws-cdk/core:suppressTemplateIndentation`\ncontext key will be used. If that is not specified, then the\ndefault value `false` will be used."
|
|
2449
|
+
},
|
|
2450
|
+
"_terminationProtection": {},
|
|
2451
|
+
"_versionReportingEnabled": {
|
|
2452
|
+
"description": "Whether version reporting is enabled for this stack\n\nControls whether the CDK Metadata resource is injected",
|
|
2453
|
+
"type": "boolean"
|
|
2454
|
+
},
|
|
2455
|
+
"account": {
|
|
2456
|
+
"description": "The AWS account into which this stack will be deployed.\n\nThis value is resolved according to the following rules:\n\n1. The value provided to `env.account` when the stack is defined. This can\n either be a concrete account (e.g. `585695031111`) or the\n `Aws.ACCOUNT_ID` token.\n3. `Aws.ACCOUNT_ID`, which represents the CloudFormation intrinsic reference\n `{ \"Ref\": \"AWS::AccountId\" }` encoded as a string token.\n\nPreferably, you should use the return value as an opaque string and not\nattempt to parse it to implement your logic. If you do, you must first\ncheck that it is a concrete value an not an unresolved token. If this\nvalue is an unresolved token (`Token.isUnresolved(stack.account)` returns\n`true`), this implies that the user wishes that this stack will synthesize\ninto an **account-agnostic template**. In this case, your code should either\nfail (throw an error, emit a synth error using `Annotations.of(construct).addError()`) or\nimplement some other account-agnostic behavior.",
|
|
2457
|
+
"type": "string"
|
|
2458
|
+
},
|
|
2459
|
+
"addPermissionsBoundaryAspect": {
|
|
2460
|
+
"description": "Adds an aspect to the stack that will apply the permissions boundary.\nThis will only add the aspect if the permissions boundary has been set"
|
|
2461
|
+
},
|
|
2462
|
+
"artifactId": {
|
|
2463
|
+
"description": "The ID of the cloud assembly artifact for this stack.",
|
|
2464
|
+
"type": "string"
|
|
2465
|
+
},
|
|
2466
|
+
"availabilityZones": {
|
|
2467
|
+
"description": "Returns the list of AZs that are available in the AWS environment\n(account/region) associated with this stack.\n\nIf the stack is environment-agnostic (either account and/or region are\ntokens), this property will return an array with 2 tokens that will resolve\nat deploy-time to the first two availability zones returned from CloudFormation's\n`Fn::GetAZs` intrinsic function.\n\nIf they are not available in the context, returns a set of dummy values and\nreports them as missing, and let the CLI resolve them by calling EC2\n`DescribeAvailabilityZones` on the target environment.\n\nTo specify a different strategy for selecting availability zones override this method.",
|
|
271
2468
|
"items": {
|
|
272
2469
|
"type": "string"
|
|
273
2470
|
},
|
|
274
2471
|
"type": "array"
|
|
275
2472
|
},
|
|
276
|
-
"
|
|
277
|
-
"description": "
|
|
2473
|
+
"bundlingRequired": {
|
|
2474
|
+
"description": "Indicates whether the stack requires bundling or not",
|
|
2475
|
+
"type": "boolean"
|
|
2476
|
+
},
|
|
2477
|
+
"dependencies": {
|
|
2478
|
+
"description": "Return the stacks this stack depends on",
|
|
278
2479
|
"items": {
|
|
279
|
-
"
|
|
2480
|
+
"$ref": "#/definitions/Stack"
|
|
280
2481
|
},
|
|
281
2482
|
"type": "array"
|
|
282
2483
|
},
|
|
283
|
-
"
|
|
284
|
-
"
|
|
285
|
-
"
|
|
2484
|
+
"environment": {
|
|
2485
|
+
"description": "The environment coordinates in which this stack is deployed. In the form\n`aws://account/region`. Use `stack.account` and `stack.region` to obtain\nthe specific values, no need to parse.\n\nYou can use this value to determine if two stacks are targeting the same\nenvironment.\n\nIf either `stack.account` or `stack.region` are not concrete values (e.g.\n`Aws.ACCOUNT_ID` or `Aws.REGION`) the special strings `unknown-account` and/or\n`unknown-region` will be used respectively to indicate this stack is\nregion/account-agnostic.",
|
|
2486
|
+
"type": "string"
|
|
286
2487
|
},
|
|
287
|
-
"
|
|
288
|
-
"description": "
|
|
2488
|
+
"generateStackArtifactId": {
|
|
2489
|
+
"description": "The artifact ID for this stack\n\nStack artifact ID is unique within the App's Cloud Assembly."
|
|
2490
|
+
},
|
|
2491
|
+
"generateStackId": {
|
|
2492
|
+
"description": "Generate an ID with respect to the given container construct."
|
|
2493
|
+
},
|
|
2494
|
+
"generateStackName": {
|
|
2495
|
+
"description": "Calculate the stack name based on the construct path\n\nThe stack name is the name under which we'll deploy the stack,\nand incorporates containing Stage names by default.\n\nGenerally this looks a lot like how logical IDs are calculated.\nThe stack name is calculated based on the construct root path,\nas follows:\n\n- Path is calculated with respect to containing App or Stage (if any)\n- If the path is one component long just use that component, otherwise\n combine them with a hash.\n\nSince the hash is quite ugly and we'd like to avoid it if possible -- but\nwe can't anymore in the general case since it has been written into legacy\nstacks. The introduction of Stages makes it possible to make this nicer however.\nWhen a Stack is nested inside a Stage, we use the path components below the\nStage, and prefix the path components of the Stage before it."
|
|
2496
|
+
},
|
|
2497
|
+
"maxResources": {
|
|
2498
|
+
"description": "Maximum number of resources in the stack\n\nSet to 0 to mean \"unlimited\"."
|
|
2499
|
+
},
|
|
2500
|
+
"nested": {
|
|
2501
|
+
"description": "Indicates if this is a nested stack, in which case `parentStack` will include a reference to it's parent.",
|
|
2502
|
+
"type": "boolean"
|
|
2503
|
+
},
|
|
2504
|
+
"nestedStackParent": {
|
|
2505
|
+
"$ref": "#/definitions/Stack",
|
|
2506
|
+
"description": "If this is a nested stack, returns it's parent stack."
|
|
2507
|
+
},
|
|
2508
|
+
"nestedStackResource": {
|
|
2509
|
+
"$ref": "#/definitions/CfnResource",
|
|
2510
|
+
"description": "If this is a nested stack, this represents its `AWS::CloudFormation::Stack`\nresource. `undefined` for top-level (non-nested) stacks."
|
|
2511
|
+
},
|
|
2512
|
+
"node": {
|
|
2513
|
+
"$ref": "#/definitions/Node",
|
|
2514
|
+
"description": "The tree node."
|
|
2515
|
+
},
|
|
2516
|
+
"notificationArns": {
|
|
2517
|
+
"description": "Returns the list of notification Amazon Resource Names (ARNs) for the current stack.",
|
|
289
2518
|
"items": {
|
|
290
2519
|
"type": "string"
|
|
291
2520
|
},
|
|
292
2521
|
"type": "array"
|
|
293
2522
|
},
|
|
294
|
-
"
|
|
295
|
-
"
|
|
296
|
-
"description": "Q-ENHANCED-INTERFACE\nDeployment stage command configuration interface for CodeBuild projects that execute custom scripts during MDAA deployment pipeline stages. Defines install dependencies, pre-deployment preparation commands, and post-deployment cleanup commands that run in CodeBuild environments to customize deployment behavior and perform environment-specific operations.\n\nUse cases: Environment preparation; Custom deployment scripts; Post-deployment cleanup; Infrastructure customization; Environment-specific configuration\n\nAWS: AWS CodeBuild project commands with install, pre-execution, and post-execution hooks for deployment stage customization\n\nValidation: install commands must be valid package manager commands; pre/post commands must be executable shell scripts; commands execute in CodeBuild Linux environment"
|
|
2523
|
+
"parseEnvironment": {
|
|
2524
|
+
"description": "Determine the various stack environment attributes."
|
|
297
2525
|
},
|
|
298
|
-
"
|
|
299
|
-
"
|
|
300
|
-
"
|
|
2526
|
+
"partition": {
|
|
2527
|
+
"description": "The partition in which this stack is defined",
|
|
2528
|
+
"type": "string"
|
|
2529
|
+
},
|
|
2530
|
+
"permissionsBoundaryArn": {
|
|
2531
|
+
"description": "If a permissions boundary has been applied on this scope or any parent scope\nthen this will return the ARN of the permissions boundary.\n\nThis will return the permissions boundary that has been applied to the most\nspecific scope.\n\nFor example:\n\nconst stage = new Stage(app, 'stage', {\n permissionsBoundary: PermissionsBoundary.fromName('stage-pb'),\n});\n\nconst stack = new Stack(stage, 'Stack', {\n permissionsBoundary: PermissionsBoundary.fromName('some-other-pb'),\n});\n\n Stack.permissionsBoundaryArn === 'arn:${AWS::Partition}:iam::${AWS::AccountId}:policy/some-other-pb';"
|
|
2532
|
+
},
|
|
2533
|
+
"region": {
|
|
2534
|
+
"description": "The AWS region into which this stack will be deployed (e.g. `us-west-2`).\n\nThis value is resolved according to the following rules:\n\n1. The value provided to `env.region` when the stack is defined. This can\n either be a concrete region (e.g. `us-west-2`) or the `Aws.REGION`\n token.\n3. `Aws.REGION`, which is represents the CloudFormation intrinsic reference\n `{ \"Ref\": \"AWS::Region\" }` encoded as a string token.\n\nPreferably, you should use the return value as an opaque string and not\nattempt to parse it to implement your logic. If you do, you must first\ncheck that it is a concrete value an not an unresolved token. If this\nvalue is an unresolved token (`Token.isUnresolved(stack.region)` returns\n`true`), this implies that the user wishes that this stack will synthesize\ninto a **region-agnostic template**. In this case, your code should either\nfail (throw an error, emit a synth error using `Annotations.of(construct).addError()`) or\nimplement some other region-agnostic behavior.",
|
|
2535
|
+
"type": "string"
|
|
2536
|
+
},
|
|
2537
|
+
"resolveExportedValue": {},
|
|
2538
|
+
"stackDependencyReasons": {
|
|
2539
|
+
"description": "Check whether this stack has a (transitive) dependency on another stack\n\nReturns the list of reasons on the dependency path, or undefined\nif there is no dependency."
|
|
2540
|
+
},
|
|
2541
|
+
"stackId": {
|
|
2542
|
+
"description": "The ID of the stack",
|
|
2543
|
+
"type": "string"
|
|
2544
|
+
},
|
|
2545
|
+
"stackName": {
|
|
2546
|
+
"description": "The concrete CloudFormation physical stack name.\n\nThis is either the name defined explicitly in the `stackName` prop or\nallocated based on the stack's location in the construct tree. Stacks that\nare directly defined under the app use their construct `id` as their stack\nname. Stacks that are defined deeper within the tree will use a hashed naming\nscheme based on the construct path to ensure uniqueness.\n\nIf you wish to obtain the deploy-time AWS::StackName intrinsic,\nyou can use `Aws.STACK_NAME` directly.",
|
|
2547
|
+
"type": "string"
|
|
2548
|
+
},
|
|
2549
|
+
"synthesizer": {
|
|
2550
|
+
"$ref": "#/definitions/IStackSynthesizer",
|
|
2551
|
+
"description": "Synthesis method for this stack"
|
|
2552
|
+
},
|
|
2553
|
+
"tags": {
|
|
2554
|
+
"$ref": "#/definitions/TagManager",
|
|
2555
|
+
"description": "Tags to be applied to the stack."
|
|
2556
|
+
},
|
|
2557
|
+
"templateFile": {
|
|
2558
|
+
"description": "The name of the CloudFormation template file emitted to the output\ndirectory during synthesis.\n\nExample value: `MyStack.template.json`",
|
|
2559
|
+
"type": "string"
|
|
2560
|
+
},
|
|
2561
|
+
"templateOptions": {
|
|
2562
|
+
"$ref": "#/definitions/ITemplateOptions",
|
|
2563
|
+
"description": "Options for CloudFormation template (like version, transform, description)."
|
|
2564
|
+
},
|
|
2565
|
+
"terminationProtection": {
|
|
2566
|
+
"description": "Whether termination protection is enabled for this stack.",
|
|
2567
|
+
"type": "boolean"
|
|
2568
|
+
},
|
|
2569
|
+
"urlSuffix": {
|
|
2570
|
+
"description": "The Amazon domain suffix for the region in which this stack is defined",
|
|
2571
|
+
"type": "string"
|
|
301
2572
|
}
|
|
302
2573
|
},
|
|
2574
|
+
"required": [
|
|
2575
|
+
"_crossRegionReferences",
|
|
2576
|
+
"_logicalIds",
|
|
2577
|
+
"_missingContext",
|
|
2578
|
+
"_stackDependencies",
|
|
2579
|
+
"_stackName",
|
|
2580
|
+
"_suppressTemplateIndentation",
|
|
2581
|
+
"_terminationProtection",
|
|
2582
|
+
"_versionReportingEnabled",
|
|
2583
|
+
"account",
|
|
2584
|
+
"addPermissionsBoundaryAspect",
|
|
2585
|
+
"artifactId",
|
|
2586
|
+
"availabilityZones",
|
|
2587
|
+
"bundlingRequired",
|
|
2588
|
+
"dependencies",
|
|
2589
|
+
"environment",
|
|
2590
|
+
"generateStackArtifactId",
|
|
2591
|
+
"generateStackId",
|
|
2592
|
+
"generateStackName",
|
|
2593
|
+
"maxResources",
|
|
2594
|
+
"nested",
|
|
2595
|
+
"node",
|
|
2596
|
+
"notificationArns",
|
|
2597
|
+
"parseEnvironment",
|
|
2598
|
+
"partition",
|
|
2599
|
+
"permissionsBoundaryArn",
|
|
2600
|
+
"region",
|
|
2601
|
+
"resolveExportedValue",
|
|
2602
|
+
"stackDependencyReasons",
|
|
2603
|
+
"stackId",
|
|
2604
|
+
"stackName",
|
|
2605
|
+
"synthesizer",
|
|
2606
|
+
"tags",
|
|
2607
|
+
"templateFile",
|
|
2608
|
+
"templateOptions",
|
|
2609
|
+
"terminationProtection",
|
|
2610
|
+
"urlSuffix"
|
|
2611
|
+
],
|
|
303
2612
|
"type": "object"
|
|
304
2613
|
},
|
|
305
2614
|
"StageCommands": {
|
|
@@ -330,6 +2639,46 @@
|
|
|
330
2639
|
},
|
|
331
2640
|
"type": "object"
|
|
332
2641
|
},
|
|
2642
|
+
"TagManager": {
|
|
2643
|
+
"additionalProperties": false,
|
|
2644
|
+
"description": "TagManager facilitates a common implementation of tagging for Constructs\n\nNormally, you do not need to use this class, as the CloudFormation specification\nwill indicate which resources are taggable. However, sometimes you will need this\nto make custom resources taggable. Used `tagManager.renderedTags` to obtain a\nvalue that will resolve to the tags at synthesis time.",
|
|
2645
|
+
"properties": {
|
|
2646
|
+
"_setTag": {},
|
|
2647
|
+
"didHaveInitialTags": {},
|
|
2648
|
+
"dynamicTags": {},
|
|
2649
|
+
"externalTagPriority": {},
|
|
2650
|
+
"parseExternalTags": {
|
|
2651
|
+
"description": "Parse external tags.\n\nSet the parseable ones into this tag manager. Save the rest (tokens, lazies) in `this.dynamicTags`."
|
|
2652
|
+
},
|
|
2653
|
+
"priorities": {},
|
|
2654
|
+
"renderedTags": {
|
|
2655
|
+
"$ref": "#/definitions/IResolvable",
|
|
2656
|
+
"description": "A lazy value that represents the rendered tags at synthesis time\n\nIf you need to make a custom construct taggable, use the value of this\nproperty to pass to the `tags` property of the underlying construct."
|
|
2657
|
+
},
|
|
2658
|
+
"resourceTypeName": {},
|
|
2659
|
+
"sortedTags": {},
|
|
2660
|
+
"tagFormatter": {},
|
|
2661
|
+
"tagPropertyName": {
|
|
2662
|
+
"description": "The property name for tag values\n\nNormally this is `tags` but some resources choose a different name. Cognito\nUserPool uses UserPoolTags",
|
|
2663
|
+
"type": "string"
|
|
2664
|
+
},
|
|
2665
|
+
"tags": {}
|
|
2666
|
+
},
|
|
2667
|
+
"required": [
|
|
2668
|
+
"_setTag",
|
|
2669
|
+
"didHaveInitialTags",
|
|
2670
|
+
"externalTagPriority",
|
|
2671
|
+
"parseExternalTags",
|
|
2672
|
+
"priorities",
|
|
2673
|
+
"renderedTags",
|
|
2674
|
+
"resourceTypeName",
|
|
2675
|
+
"sortedTags",
|
|
2676
|
+
"tagFormatter",
|
|
2677
|
+
"tagPropertyName",
|
|
2678
|
+
"tags"
|
|
2679
|
+
],
|
|
2680
|
+
"type": "object"
|
|
2681
|
+
},
|
|
333
2682
|
"ValidateStageCommands": {
|
|
334
2683
|
"additionalProperties": false,
|
|
335
2684
|
"description": "Q-ENHANCED-INTERFACE\nValidation stage command configuration interface for CodeBuild validation projects that execute infrastructure testing and compliance verification during MDAA deployment pipelines. Defines install dependencies and validation commands that run in CodeBuild environments to verify deployed infrastructure meets requirements before pipeline progression.\n\nUse cases: Infrastructure smoke testing; Compliance verification; Deployment validation; Quality gate enforcement; Post-deployment verification\n\nAWS: AWS CodeBuild validation project commands with install dependencies and validation script execution for pipeline quality gates\n\nValidation: install commands must be valid package manager commands; commands must be executable shell scripts that return appropriate exit codes for pipeline success/failure",
|
|
@@ -350,6 +2699,198 @@
|
|
|
350
2699
|
}
|
|
351
2700
|
},
|
|
352
2701
|
"type": "object"
|
|
2702
|
+
},
|
|
2703
|
+
"Version": {
|
|
2704
|
+
"additionalProperties": false,
|
|
2705
|
+
"description": "Tag the current state of a Function with a Version number\n\nAvoid using this resource directly. If you need a Version object, use\n`function.currentVersion` instead. That will add a Version object to your\ntemplate, and make sure the Version is invalidated whenever the Function\nobject changes. If you use the `Version` resource directly, you are\nresponsible for making sure it is invalidated (by changing its\nlogical ID) whenever necessary.\n\nVersion resources can then be used in `Alias` resources to refer to a\nparticular deployment of a Lambda.\n\nIf you want to ensure that you're associating the right version with\nthe right deployment, specify the `codeSha256` property while\ncreating the `Version.",
|
|
2706
|
+
"properties": {
|
|
2707
|
+
"_allowCrossEnvironment": {},
|
|
2708
|
+
"_connections": {
|
|
2709
|
+
"$ref": "#/definitions/Connections",
|
|
2710
|
+
"description": "Actual connections object for this Lambda\n\nMay be unset, in which case this Lambda is not configured use in a VPC."
|
|
2711
|
+
},
|
|
2712
|
+
"_functionUrlInvocationGrants": {
|
|
2713
|
+
"$ref": "#/definitions/Record%3Cstring%2CGrant%3E",
|
|
2714
|
+
"description": "Mapping of function URL invocation principals to grants. Used to de-dupe `grantInvokeUrl()` calls."
|
|
2715
|
+
},
|
|
2716
|
+
"_hasAddedArrayTokenStatements": {
|
|
2717
|
+
"description": "Track whether we've added statements with array token resources to the role's default policy"
|
|
2718
|
+
},
|
|
2719
|
+
"_hasAddedLiteralStatements": {
|
|
2720
|
+
"description": "Track whether we've added statements with literal resources to the role's default policy"
|
|
2721
|
+
},
|
|
2722
|
+
"_invocationGrants": {
|
|
2723
|
+
"$ref": "#/definitions/Record%3Cstring%2CGrant%3E",
|
|
2724
|
+
"description": "Mapping of invocation principals to grants. Used to de-dupe `grantInvoke()` calls."
|
|
2725
|
+
},
|
|
2726
|
+
"_latestVersion": {},
|
|
2727
|
+
"_physicalName": {},
|
|
2728
|
+
"_policyCounter": {
|
|
2729
|
+
"description": "The number of permissions added to this function"
|
|
2730
|
+
},
|
|
2731
|
+
"_skipPermissions": {
|
|
2732
|
+
"description": "Whether the user decides to skip adding permissions.\nThe only use case is for cross-account, imported lambdas\nwhere the user commits to modifying the permisssions\non the imported lambda outside CDK.",
|
|
2733
|
+
"type": "boolean"
|
|
2734
|
+
},
|
|
2735
|
+
"_warnIfCurrentVersionCalled": {
|
|
2736
|
+
"description": "Flag to delay adding a warning message until current version is invoked.",
|
|
2737
|
+
"type": "boolean"
|
|
2738
|
+
},
|
|
2739
|
+
"architecture": {
|
|
2740
|
+
"$ref": "#/definitions/Architecture",
|
|
2741
|
+
"description": "The architecture of this Lambda Function."
|
|
2742
|
+
},
|
|
2743
|
+
"canCreatePermissions": {
|
|
2744
|
+
"const": true,
|
|
2745
|
+
"default": true,
|
|
2746
|
+
"description": "Whether the addPermission() call adds any permissions\n\nTrue for new Lambdas, false for version $LATEST and imported Lambdas\nfrom different accounts.",
|
|
2747
|
+
"type": "boolean"
|
|
2748
|
+
},
|
|
2749
|
+
"connections": {
|
|
2750
|
+
"$ref": "#/definitions/Connections",
|
|
2751
|
+
"description": "Access the Connections object\n\nWill fail if not a VPC-enabled Lambda Function"
|
|
2752
|
+
},
|
|
2753
|
+
"determineProvisionedConcurrency": {
|
|
2754
|
+
"description": "Validate that the provisionedConcurrentExecutions makes sense\n\nMember must have value greater than or equal to 1"
|
|
2755
|
+
},
|
|
2756
|
+
"edgeArn": {
|
|
2757
|
+
"description": "The ARN of the version for Lambda@Edge.",
|
|
2758
|
+
"type": "string"
|
|
2759
|
+
},
|
|
2760
|
+
"env": {
|
|
2761
|
+
"$ref": "#/definitions/ResourceEnvironment",
|
|
2762
|
+
"description": "The environment this resource belongs to.\nFor resources that are created and managed by the CDK\n(generally, those created by creating new class instances like Role, Bucket, etc.),\nthis is always the same as the environment of the stack they belong to;\nhowever, for imported resources\n(those obtained from static methods like fromRoleArn, fromBucketName, etc.),\nthat might be different than the stack they were imported into."
|
|
2763
|
+
},
|
|
2764
|
+
"functionArn": {
|
|
2765
|
+
"description": "The ARN fo the function.",
|
|
2766
|
+
"type": "string"
|
|
2767
|
+
},
|
|
2768
|
+
"functionName": {
|
|
2769
|
+
"description": "The name of the function.",
|
|
2770
|
+
"type": "string"
|
|
2771
|
+
},
|
|
2772
|
+
"functionRef": {
|
|
2773
|
+
"$ref": "#/definitions/FunctionReference",
|
|
2774
|
+
"description": "A reference to a Function resource."
|
|
2775
|
+
},
|
|
2776
|
+
"grant": {},
|
|
2777
|
+
"grantPrincipal": {
|
|
2778
|
+
"$ref": "#/definitions/IPrincipal",
|
|
2779
|
+
"description": "The principal this Lambda Function is running as"
|
|
2780
|
+
},
|
|
2781
|
+
"isBoundToVpc": {
|
|
2782
|
+
"description": "Whether or not this Lambda function was bound to a VPC\n\nIf this is is `false`, trying to access the `connections` object will fail.",
|
|
2783
|
+
"type": "boolean"
|
|
2784
|
+
},
|
|
2785
|
+
"isPrincipalWithConditions": {},
|
|
2786
|
+
"lambda": {
|
|
2787
|
+
"$ref": "#/definitions/IFunction",
|
|
2788
|
+
"description": "The underlying `IFunction`"
|
|
2789
|
+
},
|
|
2790
|
+
"latestVersion": {
|
|
2791
|
+
"$ref": "#/definitions/IVersion",
|
|
2792
|
+
"description": "The `$LATEST` version of this function.\n\nNote that this is reference to a non-specific AWS Lambda version, which\nmeans the function this version refers to can return different results in\ndifferent invocations.\n\nTo obtain a reference to an explicit version which references the current\nfunction configuration, use `lambdaFunction.currentVersion` instead."
|
|
2793
|
+
},
|
|
2794
|
+
"node": {
|
|
2795
|
+
"$ref": "#/definitions/Node",
|
|
2796
|
+
"description": "The tree node."
|
|
2797
|
+
},
|
|
2798
|
+
"parsePermissionPrincipal": {
|
|
2799
|
+
"description": "Translate IPrincipal to something we can pass to AWS::Lambda::Permissions\n\nDo some nasty things because `Permission` supports a subset of what the\nfull IAM principal language supports, and we may not be able to parse strings\noutright because they may be tokens.\n\nTry to recognize some specific Principal classes first, then try a generic\nfallback."
|
|
2800
|
+
},
|
|
2801
|
+
"permissionsNode": {
|
|
2802
|
+
"$ref": "#/definitions/Node",
|
|
2803
|
+
"description": "The construct node where permissions are attached."
|
|
2804
|
+
},
|
|
2805
|
+
"physicalName": {
|
|
2806
|
+
"description": "Returns a string-encoded token that resolves to the physical name that\nshould be passed to the CloudFormation resource.\n\nThis value will resolve to one of the following:\n- a concrete value (e.g. `\"my-awesome-bucket\"`)\n- `undefined`, when a name should be generated by CloudFormation\n- a concrete name generated automatically during synthesis, in\n cross-environment scenarios.",
|
|
2807
|
+
"type": "string"
|
|
2808
|
+
},
|
|
2809
|
+
"qualifier": {
|
|
2810
|
+
"description": "The qualifier of the version or alias of this function.\nA qualifier is the identifier that's appended to a version or alias ARN.",
|
|
2811
|
+
"type": "string"
|
|
2812
|
+
},
|
|
2813
|
+
"resourceArnsForGrantInvoke": {
|
|
2814
|
+
"description": "The ARN(s) to put into the resource field of the generated IAM policy for grantInvoke()",
|
|
2815
|
+
"items": {
|
|
2816
|
+
"type": "string"
|
|
2817
|
+
},
|
|
2818
|
+
"type": "array"
|
|
2819
|
+
},
|
|
2820
|
+
"role": {
|
|
2821
|
+
"$ref": "#/definitions/IRole",
|
|
2822
|
+
"description": "The IAM role associated with this function.\n\nUndefined if the function was imported without a role."
|
|
2823
|
+
},
|
|
2824
|
+
"stack": {
|
|
2825
|
+
"$ref": "#/definitions/Stack",
|
|
2826
|
+
"description": "The stack in which this resource is defined."
|
|
2827
|
+
},
|
|
2828
|
+
"statementHasArrayTokens": {
|
|
2829
|
+
"description": "Check if a policy statement contains array tokens that would cause CloudFormation\nresolution conflicts when mixed with literal arrays in the same policy document.\n\nArray tokens are created by CloudFormation intrinsic functions that return arrays,\nsuch as Fn::Split, Fn::GetAZs, etc. These cannot be safely merged with literal\nresource arrays due to CloudFormation's token resolution limitations.\n\nIndividual string tokens within literal arrays (e.g., `[\"arn:${token}:...\"]`) are\nsafe and do not cause conflicts, so they are not detected by this method."
|
|
2830
|
+
},
|
|
2831
|
+
"validateConditionCombinations": {},
|
|
2832
|
+
"validateConditions": {},
|
|
2833
|
+
"version": {
|
|
2834
|
+
"description": "The most recently deployed version of this function.",
|
|
2835
|
+
"type": "string"
|
|
2836
|
+
},
|
|
2837
|
+
"versionRef": {
|
|
2838
|
+
"$ref": "#/definitions/VersionReference",
|
|
2839
|
+
"description": "A reference to a Version resource."
|
|
2840
|
+
}
|
|
2841
|
+
},
|
|
2842
|
+
"required": [
|
|
2843
|
+
"_allowCrossEnvironment",
|
|
2844
|
+
"_functionUrlInvocationGrants",
|
|
2845
|
+
"_hasAddedArrayTokenStatements",
|
|
2846
|
+
"_hasAddedLiteralStatements",
|
|
2847
|
+
"_invocationGrants",
|
|
2848
|
+
"_physicalName",
|
|
2849
|
+
"_policyCounter",
|
|
2850
|
+
"_warnIfCurrentVersionCalled",
|
|
2851
|
+
"architecture",
|
|
2852
|
+
"canCreatePermissions",
|
|
2853
|
+
"connections",
|
|
2854
|
+
"determineProvisionedConcurrency",
|
|
2855
|
+
"edgeArn",
|
|
2856
|
+
"env",
|
|
2857
|
+
"functionArn",
|
|
2858
|
+
"functionName",
|
|
2859
|
+
"functionRef",
|
|
2860
|
+
"grant",
|
|
2861
|
+
"grantPrincipal",
|
|
2862
|
+
"isBoundToVpc",
|
|
2863
|
+
"isPrincipalWithConditions",
|
|
2864
|
+
"lambda",
|
|
2865
|
+
"latestVersion",
|
|
2866
|
+
"node",
|
|
2867
|
+
"parsePermissionPrincipal",
|
|
2868
|
+
"permissionsNode",
|
|
2869
|
+
"physicalName",
|
|
2870
|
+
"qualifier",
|
|
2871
|
+
"resourceArnsForGrantInvoke",
|
|
2872
|
+
"stack",
|
|
2873
|
+
"statementHasArrayTokens",
|
|
2874
|
+
"validateConditionCombinations",
|
|
2875
|
+
"validateConditions",
|
|
2876
|
+
"version",
|
|
2877
|
+
"versionRef"
|
|
2878
|
+
],
|
|
2879
|
+
"type": "object"
|
|
2880
|
+
},
|
|
2881
|
+
"VersionReference": {
|
|
2882
|
+
"additionalProperties": false,
|
|
2883
|
+
"description": "A reference to a Version resource.",
|
|
2884
|
+
"properties": {
|
|
2885
|
+
"functionArn": {
|
|
2886
|
+
"description": "The FunctionArn of the Version resource.",
|
|
2887
|
+
"type": "string"
|
|
2888
|
+
}
|
|
2889
|
+
},
|
|
2890
|
+
"required": [
|
|
2891
|
+
"functionArn"
|
|
2892
|
+
],
|
|
2893
|
+
"type": "object"
|
|
353
2894
|
}
|
|
354
2895
|
},
|
|
355
2896
|
"description": "Q-ENHANCED-INTERFACE\nMDAA DevOps configuration interface for CI/CD pipeline orchestration with CodeCommit repository integration and multi-environment deployment management. Defines the complete DevOps infrastructure including source repositories, deployment pipelines, and CDK bootstrap configuration for automated MDAA infrastructure deployment across multiple environments with approval gates and validation stages.\n\nUse cases: Multi-environment CI/CD pipelines; Automated MDAA deployments; Configuration repository management; Infrastructure change management; DevOps automation\n\nAWS: AWS CodePipeline with CodeCommit source repositories, CodeBuild projects for MDAA CLI execution, and CDK bootstrap integration for infrastructure deployment\n\nValidation: mdaaCodeCommitRepo and configsCodeCommitRepo must be valid CodeCommit repository names; pipelines must contain valid PipelineConfig objects; cdkBootstrapContext must be valid CDK qualifier",
|
|
@@ -417,6 +2958,10 @@
|
|
|
417
2958
|
"$ref": "#/definitions/ValidateStageCommands",
|
|
418
2959
|
"description": "Q-ENHANCED-INTERFACE\nValidation stage command configuration interface for CodeBuild validation projects that execute infrastructure testing and compliance verification during MDAA deployment pipelines. Defines install dependencies and validation commands that run in CodeBuild environments to verify deployed infrastructure meets requirements before pipeline progression.\n\nUse cases: Infrastructure smoke testing; Compliance verification; Deployment validation; Quality gate enforcement; Post-deployment verification\n\nAWS: AWS CodeBuild validation project commands with install dependencies and validation script execution for pipeline quality gates\n\nValidation: install commands must be valid package manager commands; commands must be executable shell scripts that return appropriate exit codes for pipeline success/failure"
|
|
419
2960
|
},
|
|
2961
|
+
"sagemakerBlueprint": {
|
|
2962
|
+
"$ref": "#/definitions/MdaaSageMakerCustomBluePrintConfig",
|
|
2963
|
+
"description": "Q-ENHANCED-PROPERTY\nOptional SageMaker blueprint configuration for governed self-service deployment enabling controlled infrastructure provisioning and governance. When specified, deploys the module as a SageMaker blueprint instead of direct deployment for governed access and compliance.\n\nUse cases: Governed deployment; Self-service provisioning; SageMaker integration; Controlled access\n\nAWS: SageMaker blueprint configuration for governed infrastructure deployment and self-service provisioning\n\nValidation: Must be valid MdaaServiceCatalogProductConfig if provided; enables SageMaker deployment mode"
|
|
2964
|
+
},
|
|
420
2965
|
"service_catalog_product_config": {
|
|
421
2966
|
"$ref": "#/definitions/MdaaServiceCatalogProductConfig",
|
|
422
2967
|
"description": "Q-ENHANCED-PROPERTY\nOptional Service Catalog product configuration for governed self-service deployment enabling controlled infrastructure provisioning and governance. When specified, deploys the module as a Service Catalog product instead of direct deployment for governed access and compliance.\n\nUse cases: Governed deployment; Self-service provisioning; Service Catalog integration; Controlled access\n\nAWS: Service Catalog product configuration for governed infrastructure deployment and self-service provisioning\n\nValidation: Must be valid MdaaServiceCatalogProductConfig if provided; enables Service Catalog deployment mode"
|