pulumi-aws-native 1.38.0a1761631437__py3-none-any.whl → 1.39.0a1762376209__py3-none-any.whl

pulumi_aws_native/eks/outputs.py

@@ -46,6 +46,7 @@ __all__ = [
     'NamespaceConfigProperties',
     'NodegroupLaunchTemplateSpecification',
     'NodegroupNodeRepairConfig',
+    'NodegroupNodeRepairConfigOverrides',
     'NodegroupRemoteAccess',
     'NodegroupScalingConfig',
     'NodegroupTaint',
@@ -1317,14 +1318,59 @@ class NodegroupNodeRepairConfig(dict):
     """
     The node auto repair configuration for node group.
     """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "maxParallelNodesRepairedCount":
+            suggest = "max_parallel_nodes_repaired_count"
+        elif key == "maxParallelNodesRepairedPercentage":
+            suggest = "max_parallel_nodes_repaired_percentage"
+        elif key == "maxUnhealthyNodeThresholdCount":
+            suggest = "max_unhealthy_node_threshold_count"
+        elif key == "maxUnhealthyNodeThresholdPercentage":
+            suggest = "max_unhealthy_node_threshold_percentage"
+        elif key == "nodeRepairConfigOverrides":
+            suggest = "node_repair_config_overrides"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NodegroupNodeRepairConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NodegroupNodeRepairConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NodegroupNodeRepairConfig.__key_warning(key)
+        return super().get(key, default)
+
     def __init__(__self__, *,
-                 enabled: Optional[_builtins.bool] = None):
+                 enabled: Optional[_builtins.bool] = None,
+                 max_parallel_nodes_repaired_count: Optional[_builtins.int] = None,
+                 max_parallel_nodes_repaired_percentage: Optional[_builtins.int] = None,
+                 max_unhealthy_node_threshold_count: Optional[_builtins.int] = None,
+                 max_unhealthy_node_threshold_percentage: Optional[_builtins.int] = None,
+                 node_repair_config_overrides: Optional[Sequence['outputs.NodegroupNodeRepairConfigOverrides']] = None):
         """
         The node auto repair configuration for node group.
         :param _builtins.bool enabled: Set this value to true to enable node auto repair for the node group.
+        :param _builtins.int max_parallel_nodes_repaired_count: Specify the maximum number of nodes that can be repaired concurrently or in parallel, expressed as a count of unhealthy nodes. This gives you finer-grained control over the pace of node replacements. When using this, you cannot also set MaxParallelNodesRepairedPercentage at the same time.
+        :param _builtins.int max_parallel_nodes_repaired_percentage: Specify the maximum number of nodes that can be repaired concurrently or in parallel, expressed as a percentage of unhealthy nodes. This gives you finer-grained control over the pace of node replacements. When using this, you cannot also set MaxParallelNodesRepairedCount at the same time.
+        :param _builtins.int max_unhealthy_node_threshold_count: Specify a count threshold of unhealthy nodes, above which node auto repair actions will stop. When using this, you cannot also set MaxUnhealthyNodeThresholdPercentage at the same time.
+        :param _builtins.int max_unhealthy_node_threshold_percentage: Specify a percentage threshold of unhealthy nodes, above which node auto repair actions will stop. When using this, you cannot also set MaxUnhealthyNodeThresholdCount at the same time.
+        :param Sequence['NodegroupNodeRepairConfigOverrides'] node_repair_config_overrides: Specify granular overrides for specific repair actions. These overrides control the repair action and the repair delay time before a node is considered eligible for repair. If you use this, you must specify all the values.
         """
         if enabled is not None:
             pulumi.set(__self__, "enabled", enabled)
+        if max_parallel_nodes_repaired_count is not None:
+            pulumi.set(__self__, "max_parallel_nodes_repaired_count", max_parallel_nodes_repaired_count)
+        if max_parallel_nodes_repaired_percentage is not None:
+            pulumi.set(__self__, "max_parallel_nodes_repaired_percentage", max_parallel_nodes_repaired_percentage)
+        if max_unhealthy_node_threshold_count is not None:
+            pulumi.set(__self__, "max_unhealthy_node_threshold_count", max_unhealthy_node_threshold_count)
+        if max_unhealthy_node_threshold_percentage is not None:
+            pulumi.set(__self__, "max_unhealthy_node_threshold_percentage", max_unhealthy_node_threshold_percentage)
+        if node_repair_config_overrides is not None:
+            pulumi.set(__self__, "node_repair_config_overrides", node_repair_config_overrides)
 
     @_builtins.property
     @pulumi.getter
@@ -1334,6 +1380,128 @@ class NodegroupNodeRepairConfig(dict):
         """
         return pulumi.get(self, "enabled")
 
+    @_builtins.property
+    @pulumi.getter(name="maxParallelNodesRepairedCount")
+    def max_parallel_nodes_repaired_count(self) -> Optional[_builtins.int]:
+        """
+        Specify the maximum number of nodes that can be repaired concurrently or in parallel, expressed as a count of unhealthy nodes. This gives you finer-grained control over the pace of node replacements. When using this, you cannot also set MaxParallelNodesRepairedPercentage at the same time.
+        """
+        return pulumi.get(self, "max_parallel_nodes_repaired_count")
+
+    @_builtins.property
+    @pulumi.getter(name="maxParallelNodesRepairedPercentage")
+    def max_parallel_nodes_repaired_percentage(self) -> Optional[_builtins.int]:
+        """
+        Specify the maximum number of nodes that can be repaired concurrently or in parallel, expressed as a percentage of unhealthy nodes. This gives you finer-grained control over the pace of node replacements. When using this, you cannot also set MaxParallelNodesRepairedCount at the same time.
+        """
+        return pulumi.get(self, "max_parallel_nodes_repaired_percentage")
+
+    @_builtins.property
+    @pulumi.getter(name="maxUnhealthyNodeThresholdCount")
+    def max_unhealthy_node_threshold_count(self) -> Optional[_builtins.int]:
+        """
+        Specify a count threshold of unhealthy nodes, above which node auto repair actions will stop. When using this, you cannot also set MaxUnhealthyNodeThresholdPercentage at the same time.
+        """
+        return pulumi.get(self, "max_unhealthy_node_threshold_count")
+
+    @_builtins.property
+    @pulumi.getter(name="maxUnhealthyNodeThresholdPercentage")
+    def max_unhealthy_node_threshold_percentage(self) -> Optional[_builtins.int]:
+        """
+        Specify a percentage threshold of unhealthy nodes, above which node auto repair actions will stop. When using this, you cannot also set MaxUnhealthyNodeThresholdCount at the same time.
+        """
+        return pulumi.get(self, "max_unhealthy_node_threshold_percentage")
+
+    @_builtins.property
+    @pulumi.getter(name="nodeRepairConfigOverrides")
+    def node_repair_config_overrides(self) -> Optional[Sequence['outputs.NodegroupNodeRepairConfigOverrides']]:
+        """
+        Specify granular overrides for specific repair actions. These overrides control the repair action and the repair delay time before a node is considered eligible for repair. If you use this, you must specify all the values.
+        """
+        return pulumi.get(self, "node_repair_config_overrides")
+
+
+@pulumi.output_type
+class NodegroupNodeRepairConfigOverrides(dict):
+    """
+    Specify granular overrides for specific repair actions. These overrides control the repair action and the repair delay time before a node is considered eligible for repair. If you use this, you must specify all the values.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "minRepairWaitTimeMins":
+            suggest = "min_repair_wait_time_mins"
+        elif key == "nodeMonitoringCondition":
+            suggest = "node_monitoring_condition"
+        elif key == "nodeUnhealthyReason":
+            suggest = "node_unhealthy_reason"
+        elif key == "repairAction":
+            suggest = "repair_action"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NodegroupNodeRepairConfigOverrides. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NodegroupNodeRepairConfigOverrides.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NodegroupNodeRepairConfigOverrides.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 min_repair_wait_time_mins: Optional[_builtins.int] = None,
+                 node_monitoring_condition: Optional[_builtins.str] = None,
+                 node_unhealthy_reason: Optional[_builtins.str] = None,
+                 repair_action: Optional['NodegroupNodeRepairConfigOverridesRepairAction'] = None):
+        """
+        Specify granular overrides for specific repair actions. These overrides control the repair action and the repair delay time before a node is considered eligible for repair. If you use this, you must specify all the values.
+        :param _builtins.int min_repair_wait_time_mins: Specify the minimum time in minutes to wait before attempting to repair a node with this specific NodeMonitoringCondition and NodeUnhealthyReason.
+        :param _builtins.str node_monitoring_condition: Specify an unhealthy condition reported by the node monitoring agent that this override would apply to.
+        :param _builtins.str node_unhealthy_reason: Specify a reason reported by the node monitoring agent that this override would apply to.
+        :param 'NodegroupNodeRepairConfigOverridesRepairAction' repair_action: Specify the repair action to take for nodes when all of the specified conditions are met.
+        """
+        if min_repair_wait_time_mins is not None:
+            pulumi.set(__self__, "min_repair_wait_time_mins", min_repair_wait_time_mins)
+        if node_monitoring_condition is not None:
+            pulumi.set(__self__, "node_monitoring_condition", node_monitoring_condition)
+        if node_unhealthy_reason is not None:
+            pulumi.set(__self__, "node_unhealthy_reason", node_unhealthy_reason)
+        if repair_action is not None:
+            pulumi.set(__self__, "repair_action", repair_action)
+
+    @_builtins.property
+    @pulumi.getter(name="minRepairWaitTimeMins")
+    def min_repair_wait_time_mins(self) -> Optional[_builtins.int]:
+        """
+        Specify the minimum time in minutes to wait before attempting to repair a node with this specific NodeMonitoringCondition and NodeUnhealthyReason.
+        """
+        return pulumi.get(self, "min_repair_wait_time_mins")
+
+    @_builtins.property
+    @pulumi.getter(name="nodeMonitoringCondition")
+    def node_monitoring_condition(self) -> Optional[_builtins.str]:
+        """
+        Specify an unhealthy condition reported by the node monitoring agent that this override would apply to.
+        """
+        return pulumi.get(self, "node_monitoring_condition")
+
+    @_builtins.property
+    @pulumi.getter(name="nodeUnhealthyReason")
+    def node_unhealthy_reason(self) -> Optional[_builtins.str]:
+        """
+        Specify a reason reported by the node monitoring agent that this override would apply to.
+        """
+        return pulumi.get(self, "node_unhealthy_reason")
+
+    @_builtins.property
+    @pulumi.getter(name="repairAction")
+    def repair_action(self) -> Optional['NodegroupNodeRepairConfigOverridesRepairAction']:
+        """
+        Specify the repair action to take for nodes when all of the specified conditions are met.
+        """
+        return pulumi.get(self, "repair_action")
+
 
 @pulumi.output_type
 class NodegroupRemoteAccess(dict):

pulumi_aws_native/elasticloadbalancingv2/_inputs.py

@@ -2035,7 +2035,7 @@ if not MYPY:
         regex_values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
         values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
         """
-        The host names. The maximum size of each name is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character). You must include at least one "." character. You can include only alphabetical characters after the final "." character.
+        The host names. The maximum length of each string is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character). You must include at least one "." character. You can include only alphabetical characters after the final "." character.
          If you specify multiple strings, the condition is satisfied if one of the strings matches the host name.
         """
 elif False:
@@ -2048,7 +2048,7 @@ class ListenerRuleHostHeaderConfigArgs:
                  values: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
         """
         Information about a host header condition.
-        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] values: The host names. The maximum size of each name is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character). You must include at least one "." character. You can include only alphabetical characters after the final "." character.
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] values: The host names. The maximum length of each string is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character). You must include at least one "." character. You can include only alphabetical characters after the final "." character.
                 If you specify multiple strings, the condition is satisfied if one of the strings matches the host name.
         """
         if regex_values is not None:
@@ -2069,7 +2069,7 @@ class ListenerRuleHostHeaderConfigArgs:
     @pulumi.getter
     def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
         """
-        The host names. The maximum size of each name is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character). You must include at least one "." character. You can include only alphabetical characters after the final "." character.
+        The host names. The maximum length of each string is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character). You must include at least one "." character. You can include only alphabetical characters after the final "." character.
          If you specify multiple strings, the condition is satisfied if one of the strings matches the host name.
         """
         return pulumi.get(self, "values")
@@ -2092,7 +2092,7 @@ if not MYPY:
         regex_values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
         values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
         """
-        The strings to compare against the value of the HTTP header. The maximum size of each string is 128 characters. The comparison strings are case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character).
+        The strings to compare against the value of the HTTP header. The maximum length of each string is 128 characters. The comparison strings are case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character).
          If the same header appears multiple times in the request, we search them in order until a match is found.
          If you specify multiple strings, the condition is satisfied if one of the strings matches the value of the HTTP header. To require that all of the strings are a match, create one condition per string.
         """
@@ -2109,7 +2109,7 @@ class ListenerRuleHttpHeaderConfigArgs:
         Information about an HTTP header condition.
          There is a set of standard HTTP header fields. You can also define custom HTTP header fields.
         :param pulumi.Input[_builtins.str] http_header_name: The name of the HTTP header field. The maximum size is 40 characters. The header name is case insensitive. The allowed characters are specified by RFC 7230. Wildcards are not supported.
-        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] values: The strings to compare against the value of the HTTP header. The maximum size of each string is 128 characters. The comparison strings are case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character).
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] values: The strings to compare against the value of the HTTP header. The maximum length of each string is 128 characters. The comparison strings are case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character).
                 If the same header appears multiple times in the request, we search them in order until a match is found.
                 If you specify multiple strings, the condition is satisfied if one of the strings matches the value of the HTTP header. To require that all of the strings are a match, create one condition per string.
         """
@@ -2145,7 +2145,7 @@ class ListenerRuleHttpHeaderConfigArgs:
     @pulumi.getter
     def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
         """
-        The strings to compare against the value of the HTTP header. The maximum size of each string is 128 characters. The comparison strings are case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character).
+        The strings to compare against the value of the HTTP header. The maximum length of each string is 128 characters. The comparison strings are case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character).
          If the same header appears multiple times in the request, we search them in order until a match is found.
          If you specify multiple strings, the condition is satisfied if one of the strings matches the value of the HTTP header. To require that all of the strings are a match, create one condition per string.
         """
@@ -2164,7 +2164,7 @@ if not MYPY:
         """
         values: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
         """
-        The name of the request method. The maximum size is 40 characters. The allowed characters are A-Z, hyphen (-), and underscore (_). The comparison is case sensitive. Wildcards are not supported; therefore, the method name must be an exact match.
+        The name of the request method. The maximum length is 40 characters. The allowed characters are A-Z, hyphen (-), and underscore (_). The comparison is case sensitive. Wildcards are not supported; therefore, the method name must be an exact match.
          If you specify multiple strings, the condition is satisfied if one of the strings matches the HTTP request method. We recommend that you route GET and HEAD requests in the same way, because the response to a HEAD request may be cached.
         """
 elif False:
@@ -2177,7 +2177,7 @@ class ListenerRuleHttpRequestMethodConfigArgs:
         """
         Information about an HTTP method condition.
          HTTP defines a set of request methods, also referred to as HTTP verbs. For more information, see the [HTTP Method Registry](https://docs.aws.amazon.com/https://www.iana.org/assignments/http-methods/http-methods.xhtml). You can also define custom HTTP methods.
-        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] values: The name of the request method. The maximum size is 40 characters. The allowed characters are A-Z, hyphen (-), and underscore (_). The comparison is case sensitive. Wildcards are not supported; therefore, the method name must be an exact match.
+        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] values: The name of the request method. The maximum length is 40 characters. The allowed characters are A-Z, hyphen (-), and underscore (_). The comparison is case sensitive. Wildcards are not supported; therefore, the method name must be an exact match.
                 If you specify multiple strings, the condition is satisfied if one of the strings matches the HTTP request method. We recommend that you route GET and HEAD requests in the same way, because the response to a HEAD request may be cached.
         """
         if values is not None:
@@ -2187,7 +2187,7 @@ class ListenerRuleHttpRequestMethodConfigArgs:
     @pulumi.getter
     def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
         """
-        The name of the request method. The maximum size is 40 characters. The allowed characters are A-Z, hyphen (-), and underscore (_). The comparison is case sensitive. Wildcards are not supported; therefore, the method name must be an exact match.
+        The name of the request method. The maximum length is 40 characters. The allowed characters are A-Z, hyphen (-), and underscore (_). The comparison is case sensitive. Wildcards are not supported; therefore, the method name must be an exact match.
          If you specify multiple strings, the condition is satisfied if one of the strings matches the HTTP request method. We recommend that you route GET and HEAD requests in the same way, because the response to a HEAD request may be cached.
         """
         return pulumi.get(self, "values")
@@ -2257,7 +2257,7 @@ if not MYPY:
         """
         values: NotRequired[pulumi.Input[Sequence[pulumi.Input['ListenerRuleQueryStringKeyValueArgsDict']]]]
         """
-        The key/value pairs or values to find in the query string. The maximum size of each string is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character). To search for a literal '*' or '?' character in a query string, you must escape these characters in ``Values`` using a '\\' character.
+        The key/value pairs or values to find in the query string. The maximum length of each string is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character). To search for a literal '*' or '?' character in a query string, you must escape these characters in ``Values`` using a '\\' character.
          If you specify multiple key/value pairs or values, the condition is satisfied if one of them is found in the query string.
         """
 elif False:
@@ -2270,7 +2270,7 @@ class ListenerRuleQueryStringConfigArgs:
         """
         Information about a query string condition.
          The query string component of a URI starts after the first '?' character and is terminated by either a '#' character or the end of the URI. A typical query string contains key/value pairs separated by '&' characters. The allowed characters are specified by RFC 3986. Any character can be percentage encoded.
-        :param pulumi.Input[Sequence[pulumi.Input['ListenerRuleQueryStringKeyValueArgs']]] values: The key/value pairs or values to find in the query string. The maximum size of each string is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character). To search for a literal '*' or '?' character in a query string, you must escape these characters in ``Values`` using a '\\' character.
+        :param pulumi.Input[Sequence[pulumi.Input['ListenerRuleQueryStringKeyValueArgs']]] values: The key/value pairs or values to find in the query string. The maximum length of each string is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character). To search for a literal '*' or '?' character in a query string, you must escape these characters in ``Values`` using a '\\' character.
                 If you specify multiple key/value pairs or values, the condition is satisfied if one of them is found in the query string.
         """
         if values is not None:
@@ -2280,7 +2280,7 @@ class ListenerRuleQueryStringConfigArgs:
     @pulumi.getter
     def values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ListenerRuleQueryStringKeyValueArgs']]]]:
         """
-        The key/value pairs or values to find in the query string. The maximum size of each string is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character). To search for a literal '*' or '?' character in a query string, you must escape these characters in ``Values`` using a '\\' character.
+        The key/value pairs or values to find in the query string. The maximum length of each string is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character). To search for a literal '*' or '?' character in a query string, you must escape these characters in ``Values`` using a '\\' character.
          If you specify multiple key/value pairs or values, the condition is satisfied if one of them is found in the query string.
         """
         return pulumi.get(self, "values")

pulumi_aws_native/elasticloadbalancingv2/load_balancer.py

@@ -39,7 +39,7 @@ class LoadBalancerArgs:
                  type: Optional[pulumi.Input[_builtins.str]] = None):
         """
         The set of arguments for constructing a LoadBalancer resource.
-        :param pulumi.Input[_builtins.bool] enable_capacity_reservation_provision_stabilize: Indicates whether to enable stabilization when creating or updating an LCU reservation. This ensures that the final stack status reflects the status of the LCU reservation. The default is `false` .
+        :param pulumi.Input[_builtins.bool] enable_capacity_reservation_provision_stabilize: Indicates whether to enable stabilization when creating or updating an LCU reservation. This ensures that the final stack status reflects the status of the LCU reservation. The default is ``false``.
         :param pulumi.Input[_builtins.str] enable_prefix_for_ipv6_source_nat: [Network Load Balancers with UDP listeners] Indicates whether to use an IPv6 prefix from each subnet for source NAT. The IP address type must be ``dualstack``. The default value is ``off``.
         :param pulumi.Input[_builtins.str] enforce_security_group_inbound_rules_on_private_link_traffic: Indicates whether to evaluate inbound security group rules for traffic sent to a Network Load Balancer through privatelink. The default is ``on``.
                 You can't configure this property on a Network Load Balancer unless you associated a security group with the load balancer when you created it.
@@ -104,7 +104,7 @@ class LoadBalancerArgs:
     @pulumi.getter(name="enableCapacityReservationProvisionStabilize")
     def enable_capacity_reservation_provision_stabilize(self) -> Optional[pulumi.Input[_builtins.bool]]:
         """
-        Indicates whether to enable stabilization when creating or updating an LCU reservation. This ensures that the final stack status reflects the status of the LCU reservation. The default is `false` .
+        Indicates whether to enable stabilization when creating or updating an LCU reservation. This ensures that the final stack status reflects the status of the LCU reservation. The default is ``false``.
         """
         return pulumi.get(self, "enable_capacity_reservation_provision_stabilize")
 
@@ -312,7 +312,7 @@ class LoadBalancer(pulumi.CustomResource):
 
         :param str resource_name: The name of the resource.
         :param pulumi.ResourceOptions opts: Options for the resource.
-        :param pulumi.Input[_builtins.bool] enable_capacity_reservation_provision_stabilize: Indicates whether to enable stabilization when creating or updating an LCU reservation. This ensures that the final stack status reflects the status of the LCU reservation. The default is `false` .
+        :param pulumi.Input[_builtins.bool] enable_capacity_reservation_provision_stabilize: Indicates whether to enable stabilization when creating or updating an LCU reservation. This ensures that the final stack status reflects the status of the LCU reservation. The default is ``false``.
         :param pulumi.Input[_builtins.str] enable_prefix_for_ipv6_source_nat: [Network Load Balancers with UDP listeners] Indicates whether to use an IPv6 prefix from each subnet for source NAT. The IP address type must be ``dualstack``. The default value is ``off``.
         :param pulumi.Input[_builtins.str] enforce_security_group_inbound_rules_on_private_link_traffic: Indicates whether to evaluate inbound security group rules for traffic sent to a Network Load Balancer through privatelink. The default is ``on``.
                 You can't configure this property on a Network Load Balancer unless you associated a security group with the load balancer when you created it.
@@ -475,7 +475,7 @@ class LoadBalancer(pulumi.CustomResource):
     @pulumi.getter(name="enableCapacityReservationProvisionStabilize")
     def enable_capacity_reservation_provision_stabilize(self) -> pulumi.Output[Optional[_builtins.bool]]:
         """
-        Indicates whether to enable stabilization when creating or updating an LCU reservation. This ensures that the final stack status reflects the status of the LCU reservation. The default is `false` .
+        Indicates whether to enable stabilization when creating or updating an LCU reservation. This ensures that the final stack status reflects the status of the LCU reservation. The default is ``false``.
         """
         return pulumi.get(self, "enable_capacity_reservation_provision_stabilize")
 

pulumi_aws_native/elasticloadbalancingv2/outputs.py

@@ -1589,7 +1589,7 @@ class ListenerRuleHostHeaderConfig(dict):
                  values: Optional[Sequence[_builtins.str]] = None):
         """
         Information about a host header condition.
-        :param Sequence[_builtins.str] values: The host names. The maximum size of each name is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character). You must include at least one "." character. You can include only alphabetical characters after the final "." character.
+        :param Sequence[_builtins.str] values: The host names. The maximum length of each string is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character). You must include at least one "." character. You can include only alphabetical characters after the final "." character.
                 If you specify multiple strings, the condition is satisfied if one of the strings matches the host name.
         """
         if regex_values is not None:
@@ -1606,7 +1606,7 @@ class ListenerRuleHostHeaderConfig(dict):
     @pulumi.getter
     def values(self) -> Optional[Sequence[_builtins.str]]:
         """
-        The host names. The maximum size of each name is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character). You must include at least one "." character. You can include only alphabetical characters after the final "." character.
+        The host names. The maximum length of each string is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character). You must include at least one "." character. You can include only alphabetical characters after the final "." character.
          If you specify multiple strings, the condition is satisfied if one of the strings matches the host name.
         """
         return pulumi.get(self, "values")
@@ -1645,7 +1645,7 @@ class ListenerRuleHttpHeaderConfig(dict):
         Information about an HTTP header condition.
          There is a set of standard HTTP header fields. You can also define custom HTTP header fields.
         :param _builtins.str http_header_name: The name of the HTTP header field. The maximum size is 40 characters. The header name is case insensitive. The allowed characters are specified by RFC 7230. Wildcards are not supported.
-        :param Sequence[_builtins.str] values: The strings to compare against the value of the HTTP header. The maximum size of each string is 128 characters. The comparison strings are case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character).
+        :param Sequence[_builtins.str] values: The strings to compare against the value of the HTTP header. The maximum length of each string is 128 characters. The comparison strings are case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character).
                 If the same header appears multiple times in the request, we search them in order until a match is found.
                 If you specify multiple strings, the condition is satisfied if one of the strings matches the value of the HTTP header. To require that all of the strings are a match, create one condition per string.
         """
@@ -1673,7 +1673,7 @@ class ListenerRuleHttpHeaderConfig(dict):
     @pulumi.getter
     def values(self) -> Optional[Sequence[_builtins.str]]:
         """
-        The strings to compare against the value of the HTTP header. The maximum size of each string is 128 characters. The comparison strings are case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character).
+        The strings to compare against the value of the HTTP header. The maximum length of each string is 128 characters. The comparison strings are case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character).
          If the same header appears multiple times in the request, we search them in order until a match is found.
          If you specify multiple strings, the condition is satisfied if one of the strings matches the value of the HTTP header. To require that all of the strings are a match, create one condition per string.
         """
@@ -1691,7 +1691,7 @@ class ListenerRuleHttpRequestMethodConfig(dict):
         """
         Information about an HTTP method condition.
          HTTP defines a set of request methods, also referred to as HTTP verbs. For more information, see the [HTTP Method Registry](https://docs.aws.amazon.com/https://www.iana.org/assignments/http-methods/http-methods.xhtml). You can also define custom HTTP methods.
-        :param Sequence[_builtins.str] values: The name of the request method. The maximum size is 40 characters. The allowed characters are A-Z, hyphen (-), and underscore (_). The comparison is case sensitive. Wildcards are not supported; therefore, the method name must be an exact match.
+        :param Sequence[_builtins.str] values: The name of the request method. The maximum length is 40 characters. The allowed characters are A-Z, hyphen (-), and underscore (_). The comparison is case sensitive. Wildcards are not supported; therefore, the method name must be an exact match.
                 If you specify multiple strings, the condition is satisfied if one of the strings matches the HTTP request method. We recommend that you route GET and HEAD requests in the same way, because the response to a HEAD request may be cached.
         """
         if values is not None:
@@ -1701,7 +1701,7 @@ class ListenerRuleHttpRequestMethodConfig(dict):
     @pulumi.getter
     def values(self) -> Optional[Sequence[_builtins.str]]:
         """
-        The name of the request method. The maximum size is 40 characters. The allowed characters are A-Z, hyphen (-), and underscore (_). The comparison is case sensitive. Wildcards are not supported; therefore, the method name must be an exact match.
+        The name of the request method. The maximum length is 40 characters. The allowed characters are A-Z, hyphen (-), and underscore (_). The comparison is case sensitive. Wildcards are not supported; therefore, the method name must be an exact match.
          If you specify multiple strings, the condition is satisfied if one of the strings matches the HTTP request method. We recommend that you route GET and HEAD requests in the same way, because the response to a HEAD request may be cached.
         """
         return pulumi.get(self, "values")
@@ -1768,7 +1768,7 @@ class ListenerRuleQueryStringConfig(dict):
         """
         Information about a query string condition.
          The query string component of a URI starts after the first '?' character and is terminated by either a '#' character or the end of the URI. A typical query string contains key/value pairs separated by '&' characters. The allowed characters are specified by RFC 3986. Any character can be percentage encoded.
-        :param Sequence['ListenerRuleQueryStringKeyValue'] values: The key/value pairs or values to find in the query string. The maximum size of each string is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character). To search for a literal '*' or '?' character in a query string, you must escape these characters in ``Values`` using a '\\' character.
+        :param Sequence['ListenerRuleQueryStringKeyValue'] values: The key/value pairs or values to find in the query string. The maximum length of each string is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character). To search for a literal '*' or '?' character in a query string, you must escape these characters in ``Values`` using a '\\' character.
                 If you specify multiple key/value pairs or values, the condition is satisfied if one of them is found in the query string.
         """
         if values is not None:
@@ -1778,7 +1778,7 @@ class ListenerRuleQueryStringConfig(dict):
     @pulumi.getter
     def values(self) -> Optional[Sequence['outputs.ListenerRuleQueryStringKeyValue']]:
         """
-        The key/value pairs or values to find in the query string. The maximum size of each string is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character). To search for a literal '*' or '?' character in a query string, you must escape these characters in ``Values`` using a '\\' character.
+        The key/value pairs or values to find in the query string. The maximum length of each string is 128 characters. The comparison is case insensitive. The following wildcard characters are supported: * (matches 0 or more characters) and ? (matches exactly 1 character). To search for a literal '*' or '?' character in a query string, you must escape these characters in ``Values`` using a '\\' character.
          If you specify multiple key/value pairs or values, the condition is satisfied if one of them is found in the query string.
         """
         return pulumi.get(self, "values")

pulumi_aws_native/glue/__init__.py

@@ -11,12 +11,14 @@ from .crawler import *
 from .database import *
 from .get_crawler import *
 from .get_database import *
+from .get_integration_resource_property import *
 from .get_job import *
 from .get_registry import *
 from .get_schema import *
 from .get_schema_version import *
 from .get_trigger import *
 from .get_usage_profile import *
+from .integration_resource_property import *
 from .job import *
 from .registry import *
 from .schema import *

pulumi_aws_native/glue/_inputs.py

@@ -66,6 +66,10 @@ __all__ = [
     'SchemaVersionSchemaArgsDict',
     'SchemaVersionArgs',
     'SchemaVersionArgsDict',
+    'SourceProcessingPropertiesPropertiesArgs',
+    'SourceProcessingPropertiesPropertiesArgsDict',
+    'TargetProcessingPropertiesPropertiesArgs',
+    'TargetProcessingPropertiesPropertiesArgsDict',
     'TriggerActionArgs',
     'TriggerActionArgsDict',
     'TriggerConditionArgs',
@@ -1980,6 +1984,136 @@ class SchemaVersionArgs:
         pulumi.set(self, "version_number", value)
 
 
+if not MYPY:
+    class SourceProcessingPropertiesPropertiesArgsDict(TypedDict):
+        """
+        The resource properties associated with the integration source.
+        """
+        role_arn: pulumi.Input[_builtins.str]
+        """
+        The IAM role to access the Glue connection.
+        """
+elif False:
+    SourceProcessingPropertiesPropertiesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class SourceProcessingPropertiesPropertiesArgs:
+    def __init__(__self__, *,
+                 role_arn: pulumi.Input[_builtins.str]):
+        """
+        The resource properties associated with the integration source.
+        :param pulumi.Input[_builtins.str] role_arn: The IAM role to access the Glue connection.
+        """
+        pulumi.set(__self__, "role_arn", role_arn)
+
+    @_builtins.property
+    @pulumi.getter(name="roleArn")
+    def role_arn(self) -> pulumi.Input[_builtins.str]:
+        """
+        The IAM role to access the Glue connection.
+        """
+        return pulumi.get(self, "role_arn")
+
+    @role_arn.setter
+    def role_arn(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "role_arn", value)
+
+
+if not MYPY:
+    class TargetProcessingPropertiesPropertiesArgsDict(TypedDict):
+        """
+        The resource properties associated with the integration target.
+        """
+        role_arn: pulumi.Input[_builtins.str]
+        """
+        The IAM role to access the Glue database.
+        """
+        connection_name: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The Glue network connection to configure the Glue job running in the customer VPC.
+        """
+        event_bus_arn: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The ARN of an Eventbridge event bus to receive the integration status notification.
+        """
+        kms_arn: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The ARN of the KMS key used for encryption.
+        """
+elif False:
+    TargetProcessingPropertiesPropertiesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class TargetProcessingPropertiesPropertiesArgs:
+    def __init__(__self__, *,
+                 role_arn: pulumi.Input[_builtins.str],
+                 connection_name: Optional[pulumi.Input[_builtins.str]] = None,
+                 event_bus_arn: Optional[pulumi.Input[_builtins.str]] = None,
+                 kms_arn: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        The resource properties associated with the integration target.
+        :param pulumi.Input[_builtins.str] role_arn: The IAM role to access the Glue database.
+        :param pulumi.Input[_builtins.str] connection_name: The Glue network connection to configure the Glue job running in the customer VPC.
+        :param pulumi.Input[_builtins.str] event_bus_arn: The ARN of an Eventbridge event bus to receive the integration status notification.
+        :param pulumi.Input[_builtins.str] kms_arn: The ARN of the KMS key used for encryption.
+        """
+        pulumi.set(__self__, "role_arn", role_arn)
+        if connection_name is not None:
+            pulumi.set(__self__, "connection_name", connection_name)
+        if event_bus_arn is not None:
+            pulumi.set(__self__, "event_bus_arn", event_bus_arn)
+        if kms_arn is not None:
+            pulumi.set(__self__, "kms_arn", kms_arn)
+
+    @_builtins.property
+    @pulumi.getter(name="roleArn")
+    def role_arn(self) -> pulumi.Input[_builtins.str]:
+        """
+        The IAM role to access the Glue database.
+        """
+        return pulumi.get(self, "role_arn")
+
+    @role_arn.setter
+    def role_arn(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "role_arn", value)
+
+    @_builtins.property
+    @pulumi.getter(name="connectionName")
+    def connection_name(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The Glue network connection to configure the Glue job running in the customer VPC.
+        """
+        return pulumi.get(self, "connection_name")
+
+    @connection_name.setter
+    def connection_name(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "connection_name", value)
+
+    @_builtins.property
+    @pulumi.getter(name="eventBusArn")
+    def event_bus_arn(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The ARN of an Eventbridge event bus to receive the integration status notification.
+        """
+        return pulumi.get(self, "event_bus_arn")
+
+    @event_bus_arn.setter
+    def event_bus_arn(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "event_bus_arn", value)
+
+    @_builtins.property
+    @pulumi.getter(name="kmsArn")
+    def kms_arn(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The ARN of the KMS key used for encryption.
+        """
+        return pulumi.get(self, "kms_arn")
+
+    @kms_arn.setter
+    def kms_arn(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "kms_arn", value)
+
+
 if not MYPY:
     class TriggerActionArgsDict(TypedDict):
         """