aws-cdk.aws-eks-v2-alpha 2.180.0a0__tar.gz → 2.181.1a0__tar.gz

{aws_cdk_aws_eks_v2_alpha-2.180.0a0/src/aws_cdk.aws_eks_v2_alpha.egg-info → aws_cdk_aws_eks_v2_alpha-2.181.1a0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aws-cdk.aws-eks-v2-alpha
-Version: 2.180.0a0
+Version: 2.181.1a0
 Summary: The CDK Construct Library for AWS::EKS
 Home-page: https://github.com/aws/aws-cdk
 Author: Amazon Web Services
@@ -23,7 +23,7 @@ Requires-Python: ~=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: NOTICE
-Requires-Dist: aws-cdk-lib<3.0.0,>=2.180.0
+Requires-Dist: aws-cdk-lib<3.0.0,>=2.181.1
 Requires-Dist: constructs<11.0.0,>=10.0.0
 Requires-Dist: jsii<2.0.0,>=1.106.0
 Requires-Dist: publication>=0.0.3
@@ -131,6 +131,121 @@ eks.Cluster(self, "hello-eks",
 )
 ```
 
+## EKS Auto Mode
+
+[Amazon EKS Auto Mode](https://aws.amazon.com/eks/auto-mode/) extends AWS management of Kubernetes clusters beyond the cluster itself, allowing AWS to set up and manage the infrastructure that enables the smooth operation of your workloads.
+
+### Using Auto Mode
+
+While `aws-eks` uses `DefaultCapacityType.NODEGROUP` by default, `aws-eks-v2` uses `DefaultCapacityType.AUTOMODE` as the default capacity type.
+
+Auto Mode is enabled by default when creating a new cluster without specifying any capacity-related properties:
+
+```python
+# Create EKS cluster with Auto Mode implicitly enabled
+cluster = eks.Cluster(self, "EksAutoCluster",
+    version=eks.KubernetesVersion.V1_32
+)
+```
+
+You can also explicitly enable Auto Mode using `defaultCapacityType`:
+
+```python
+# Create EKS cluster with Auto Mode explicitly enabled
+cluster = eks.Cluster(self, "EksAutoCluster",
+    version=eks.KubernetesVersion.V1_32,
+    default_capacity_type=eks.DefaultCapacityType.AUTOMODE
+)
+```
+
+### Node Pools
+
+When Auto Mode is enabled, the cluster comes with two default node pools:
+
+* `system`: For running system components and add-ons
+* `general-purpose`: For running your application workloads
+
+These node pools are managed automatically by EKS. You can configure which node pools to enable through the `compute` property:
+
+```python
+cluster = eks.Cluster(self, "EksAutoCluster",
+    version=eks.KubernetesVersion.V1_32,
+    default_capacity_type=eks.DefaultCapacityType.AUTOMODE,
+    compute=eks.ComputeConfig(
+        node_pools=["system", "general-purpose"]
+    )
+)
+```
+
+For more information, see [Create a Node Pool for EKS Auto Mode](https://docs.aws.amazon.com/eks/latest/userguide/create-node-pool.html).
+
+### Node Groups as the default capacity type
+
+If you prefer to manage your own node groups instead of using Auto Mode, you can use the traditional node group approach by specifying `defaultCapacityType` as `NODEGROUP`:
+
+```python
+# Create EKS cluster with traditional managed node group
+cluster = eks.Cluster(self, "EksCluster",
+    version=eks.KubernetesVersion.V1_32,
+    default_capacity_type=eks.DefaultCapacityType.NODEGROUP,
+    default_capacity=3,  # Number of instances
+    default_capacity_instance=ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.LARGE)
+)
+```
+
+You can also create a cluster with no initial capacity and add node groups later:
+
+```python
+cluster = eks.Cluster(self, "EksCluster",
+    version=eks.KubernetesVersion.V1_32,
+    default_capacity_type=eks.DefaultCapacityType.NODEGROUP,
+    default_capacity=0
+)
+
+# Add node groups as needed
+cluster.add_nodegroup_capacity("custom-node-group",
+    min_size=1,
+    max_size=3,
+    instance_types=[ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.LARGE)]
+)
+```
+
+Read [Managed node groups](#managed-node-groups) for more information on how to add node groups to the cluster.
+
+### Mixed with Auto Mode and Node Groups
+
+You can combine Auto Mode with traditional node groups for specific workload requirements:
+
+```python
+cluster = eks.Cluster(self, "Cluster",
+    version=eks.KubernetesVersion.V1_32,
+    default_capacity_type=eks.DefaultCapacityType.AUTOMODE,
+    compute=eks.ComputeConfig(
+        node_pools=["system", "general-purpose"]
+    )
+)
+
+# Add specialized node group for specific workloads
+cluster.add_nodegroup_capacity("specialized-workload",
+    min_size=1,
+    max_size=3,
+    instance_types=[ec2.InstanceType.of(ec2.InstanceClass.C5, ec2.InstanceSize.XLARGE)],
+    labels={
+        "workload": "specialized"
+    }
+)
+```
+
+### Important Notes
+
+1. Auto Mode and traditional capacity management are mutually exclusive at the default capacity level. You cannot opt in to Auto Mode and specify `defaultCapacity` or `defaultCapacityInstance`.
+2. When Auto Mode is enabled:
+
+   * The cluster will automatically manage compute resources
+   * Node pools cannot be modified, only enabled or disabled
+   * EKS will handle scaling and management of the node pools
+3. Auto Mode requires specific IAM permissions. The construct will automatically attach the required managed policies.
+
 ### Managed node groups
 
 Amazon EKS managed node groups automate the provisioning and lifecycle management of nodes (Amazon EC2 instances) for Amazon EKS Kubernetes clusters.
@@ -138,15 +253,21 @@ With Amazon EKS managed node groups, you don't need to separately provision or r
 
 > For more details visit [Amazon EKS Managed Node Groups](https://docs.aws.amazon.com/eks/latest/userguide/managed-node-groups.html).
 
-**Managed Node Groups are the recommended way to allocate cluster capacity.**
+By default, when using `DefaultCapacityType.NODEGROUP`, this library will allocate a managed node group with 2 *m5.large* instances (this instance type suits most common use-cases, and is good value for money).
 
-By default, this library will allocate a managed node group with 2 *m5.large* instances (this instance type suits most common use-cases, and is good value for money).
+```python
+eks.Cluster(self, "HelloEKS",
+    version=eks.KubernetesVersion.V1_32,
+    default_capacity_type=eks.DefaultCapacityType.NODEGROUP
+)
+```
 
 At cluster instantiation time, you can customize the number of instances and their type:
 
 ```python
 eks.Cluster(self, "HelloEKS",
     version=eks.KubernetesVersion.V1_32,
+    default_capacity_type=eks.DefaultCapacityType.NODEGROUP,
     default_capacity=5,
     default_capacity_instance=ec2.InstanceType.of(ec2.InstanceClass.M5, ec2.InstanceSize.SMALL)
 )
@@ -159,6 +280,7 @@ Additional customizations are available post instantiation. To apply them, set t
 ```python
 cluster = eks.Cluster(self, "HelloEKS",
     version=eks.KubernetesVersion.V1_32,
+    default_capacity_type=eks.DefaultCapacityType.NODEGROUP,
     default_capacity=0
 )
 

{aws_cdk_aws_eks_v2_alpha-2.180.0a0 → aws_cdk_aws_eks_v2_alpha-2.181.1a0}/README.md

@@ -100,6 +100,121 @@ eks.Cluster(self, "hello-eks",
 )
 ```
 
+## EKS Auto Mode
+
+[Amazon EKS Auto Mode](https://aws.amazon.com/eks/auto-mode/) extends AWS management of Kubernetes clusters beyond the cluster itself, allowing AWS to set up and manage the infrastructure that enables the smooth operation of your workloads.
+
+### Using Auto Mode
+
+While `aws-eks` uses `DefaultCapacityType.NODEGROUP` by default, `aws-eks-v2` uses `DefaultCapacityType.AUTOMODE` as the default capacity type.
+
+Auto Mode is enabled by default when creating a new cluster without specifying any capacity-related properties:
+
+```python
+# Create EKS cluster with Auto Mode implicitly enabled
+cluster = eks.Cluster(self, "EksAutoCluster",
+    version=eks.KubernetesVersion.V1_32
+)
+```
+
+You can also explicitly enable Auto Mode using `defaultCapacityType`:
+
+```python
+# Create EKS cluster with Auto Mode explicitly enabled
+cluster = eks.Cluster(self, "EksAutoCluster",
+    version=eks.KubernetesVersion.V1_32,
+    default_capacity_type=eks.DefaultCapacityType.AUTOMODE
+)
+```
+
+### Node Pools
+
+When Auto Mode is enabled, the cluster comes with two default node pools:
+
+* `system`: For running system components and add-ons
+* `general-purpose`: For running your application workloads
+
+These node pools are managed automatically by EKS. You can configure which node pools to enable through the `compute` property:
+
+```python
+cluster = eks.Cluster(self, "EksAutoCluster",
+    version=eks.KubernetesVersion.V1_32,
+    default_capacity_type=eks.DefaultCapacityType.AUTOMODE,
+    compute=eks.ComputeConfig(
+        node_pools=["system", "general-purpose"]
+    )
+)
+```
+
+For more information, see [Create a Node Pool for EKS Auto Mode](https://docs.aws.amazon.com/eks/latest/userguide/create-node-pool.html).
+
+### Node Groups as the default capacity type
+
+If you prefer to manage your own node groups instead of using Auto Mode, you can use the traditional node group approach by specifying `defaultCapacityType` as `NODEGROUP`:
+
+```python
+# Create EKS cluster with traditional managed node group
+cluster = eks.Cluster(self, "EksCluster",
+    version=eks.KubernetesVersion.V1_32,
+    default_capacity_type=eks.DefaultCapacityType.NODEGROUP,
+    default_capacity=3,  # Number of instances
+    default_capacity_instance=ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.LARGE)
+)
+```
+
+You can also create a cluster with no initial capacity and add node groups later:
+
+```python
+cluster = eks.Cluster(self, "EksCluster",
+    version=eks.KubernetesVersion.V1_32,
+    default_capacity_type=eks.DefaultCapacityType.NODEGROUP,
+    default_capacity=0
+)
+
+# Add node groups as needed
+cluster.add_nodegroup_capacity("custom-node-group",
+    min_size=1,
+    max_size=3,
+    instance_types=[ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.LARGE)]
+)
+```
+
+Read [Managed node groups](#managed-node-groups) for more information on how to add node groups to the cluster.
+
+### Mixed with Auto Mode and Node Groups
+
+You can combine Auto Mode with traditional node groups for specific workload requirements:
+
+```python
+cluster = eks.Cluster(self, "Cluster",
+    version=eks.KubernetesVersion.V1_32,
+    default_capacity_type=eks.DefaultCapacityType.AUTOMODE,
+    compute=eks.ComputeConfig(
+        node_pools=["system", "general-purpose"]
+    )
+)
+
+# Add specialized node group for specific workloads
+cluster.add_nodegroup_capacity("specialized-workload",
+    min_size=1,
+    max_size=3,
+    instance_types=[ec2.InstanceType.of(ec2.InstanceClass.C5, ec2.InstanceSize.XLARGE)],
+    labels={
+        "workload": "specialized"
+    }
+)
+```
+
+### Important Notes
+
+1. Auto Mode and traditional capacity management are mutually exclusive at the default capacity level. You cannot opt in to Auto Mode and specify `defaultCapacity` or `defaultCapacityInstance`.
+2. When Auto Mode is enabled:
+
+   * The cluster will automatically manage compute resources
+   * Node pools cannot be modified, only enabled or disabled
+   * EKS will handle scaling and management of the node pools
+3. Auto Mode requires specific IAM permissions. The construct will automatically attach the required managed policies.
+
 ### Managed node groups
 
 Amazon EKS managed node groups automate the provisioning and lifecycle management of nodes (Amazon EC2 instances) for Amazon EKS Kubernetes clusters.
@@ -107,15 +222,21 @@ With Amazon EKS managed node groups, you don't need to separately provision or r
 
 > For more details visit [Amazon EKS Managed Node Groups](https://docs.aws.amazon.com/eks/latest/userguide/managed-node-groups.html).
 
-**Managed Node Groups are the recommended way to allocate cluster capacity.**
+By default, when using `DefaultCapacityType.NODEGROUP`, this library will allocate a managed node group with 2 *m5.large* instances (this instance type suits most common use-cases, and is good value for money).
 
-By default, this library will allocate a managed node group with 2 *m5.large* instances (this instance type suits most common use-cases, and is good value for money).
+```python
+eks.Cluster(self, "HelloEKS",
+    version=eks.KubernetesVersion.V1_32,
+    default_capacity_type=eks.DefaultCapacityType.NODEGROUP
+)
+```
 
 At cluster instantiation time, you can customize the number of instances and their type:
 
 ```python
 eks.Cluster(self, "HelloEKS",
     version=eks.KubernetesVersion.V1_32,
+    default_capacity_type=eks.DefaultCapacityType.NODEGROUP,
     default_capacity=5,
     default_capacity_instance=ec2.InstanceType.of(ec2.InstanceClass.M5, ec2.InstanceSize.SMALL)
 )
@@ -128,6 +249,7 @@ Additional customizations are available post instantiation. To apply them, set t
 ```python
 cluster = eks.Cluster(self, "HelloEKS",
     version=eks.KubernetesVersion.V1_32,
+    default_capacity_type=eks.DefaultCapacityType.NODEGROUP,
     default_capacity=0
 )
 

{aws_cdk_aws_eks_v2_alpha-2.180.0a0 → aws_cdk_aws_eks_v2_alpha-2.181.1a0}/setup.py

@@ -5,7 +5,7 @@ kwargs = json.loads(
     """
 {
     "name": "aws-cdk.aws-eks-v2-alpha",
-    "version": "2.180.0.a0",
+    "version": "2.181.1.a0",
     "description": "The CDK Construct Library for AWS::EKS",
     "license": "Apache-2.0",
     "url": "https://github.com/aws/aws-cdk",
@@ -26,7 +26,7 @@ kwargs = json.loads(
     ],
     "package_data": {
         "aws_cdk.aws_eks_v2_alpha._jsii": [
-            "aws-eks-v2-alpha@2.180.0-alpha.0.jsii.tgz"
+            "aws-eks-v2-alpha@2.181.1-alpha.0.jsii.tgz"
         ],
         "aws_cdk.aws_eks_v2_alpha": [
             "py.typed"
@@ -34,7 +34,7 @@ kwargs = json.loads(
     },
     "python_requires": "~=3.8",
     "install_requires": [
-        "aws-cdk-lib>=2.180.0, <3.0.0",
+        "aws-cdk-lib>=2.181.1, <3.0.0",
         "constructs>=10.0.0, <11.0.0",
         "jsii>=1.106.0, <2.0.0",
         "publication>=0.0.3",

{aws_cdk_aws_eks_v2_alpha-2.180.0a0 → aws_cdk_aws_eks_v2_alpha-2.181.1a0}/src/aws_cdk/aws_eks_v2_alpha/__init__.py

@@ -101,6 +101,121 @@ eks.Cluster(self, "hello-eks",
 )
 ```
 
+## EKS Auto Mode
+
+[Amazon EKS Auto Mode](https://aws.amazon.com/eks/auto-mode/) extends AWS management of Kubernetes clusters beyond the cluster itself, allowing AWS to set up and manage the infrastructure that enables the smooth operation of your workloads.
+
+### Using Auto Mode
+
+While `aws-eks` uses `DefaultCapacityType.NODEGROUP` by default, `aws-eks-v2` uses `DefaultCapacityType.AUTOMODE` as the default capacity type.
+
+Auto Mode is enabled by default when creating a new cluster without specifying any capacity-related properties:
+
+```python
+# Create EKS cluster with Auto Mode implicitly enabled
+cluster = eks.Cluster(self, "EksAutoCluster",
+    version=eks.KubernetesVersion.V1_32
+)
+```
+
+You can also explicitly enable Auto Mode using `defaultCapacityType`:
+
+```python
+# Create EKS cluster with Auto Mode explicitly enabled
+cluster = eks.Cluster(self, "EksAutoCluster",
+    version=eks.KubernetesVersion.V1_32,
+    default_capacity_type=eks.DefaultCapacityType.AUTOMODE
+)
+```
+
+### Node Pools
+
+When Auto Mode is enabled, the cluster comes with two default node pools:
+
+* `system`: For running system components and add-ons
+* `general-purpose`: For running your application workloads
+
+These node pools are managed automatically by EKS. You can configure which node pools to enable through the `compute` property:
+
+```python
+cluster = eks.Cluster(self, "EksAutoCluster",
+    version=eks.KubernetesVersion.V1_32,
+    default_capacity_type=eks.DefaultCapacityType.AUTOMODE,
+    compute=eks.ComputeConfig(
+        node_pools=["system", "general-purpose"]
+    )
+)
+```
+
+For more information, see [Create a Node Pool for EKS Auto Mode](https://docs.aws.amazon.com/eks/latest/userguide/create-node-pool.html).
+
+### Node Groups as the default capacity type
+
+If you prefer to manage your own node groups instead of using Auto Mode, you can use the traditional node group approach by specifying `defaultCapacityType` as `NODEGROUP`:
+
+```python
+# Create EKS cluster with traditional managed node group
+cluster = eks.Cluster(self, "EksCluster",
+    version=eks.KubernetesVersion.V1_32,
+    default_capacity_type=eks.DefaultCapacityType.NODEGROUP,
+    default_capacity=3,  # Number of instances
+    default_capacity_instance=ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.LARGE)
+)
+```
+
+You can also create a cluster with no initial capacity and add node groups later:
+
+```python
+cluster = eks.Cluster(self, "EksCluster",
+    version=eks.KubernetesVersion.V1_32,
+    default_capacity_type=eks.DefaultCapacityType.NODEGROUP,
+    default_capacity=0
+)
+
+# Add node groups as needed
+cluster.add_nodegroup_capacity("custom-node-group",
+    min_size=1,
+    max_size=3,
+    instance_types=[ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.LARGE)]
+)
+```
+
+Read [Managed node groups](#managed-node-groups) for more information on how to add node groups to the cluster.
+
+### Mixed with Auto Mode and Node Groups
+
+You can combine Auto Mode with traditional node groups for specific workload requirements:
+
+```python
+cluster = eks.Cluster(self, "Cluster",
+    version=eks.KubernetesVersion.V1_32,
+    default_capacity_type=eks.DefaultCapacityType.AUTOMODE,
+    compute=eks.ComputeConfig(
+        node_pools=["system", "general-purpose"]
+    )
+)
+
+# Add specialized node group for specific workloads
+cluster.add_nodegroup_capacity("specialized-workload",
+    min_size=1,
+    max_size=3,
+    instance_types=[ec2.InstanceType.of(ec2.InstanceClass.C5, ec2.InstanceSize.XLARGE)],
+    labels={
+        "workload": "specialized"
+    }
+)
+```
+
+### Important Notes
+
+1. Auto Mode and traditional capacity management are mutually exclusive at the default capacity level. You cannot opt in to Auto Mode and specify `defaultCapacity` or `defaultCapacityInstance`.
+2. When Auto Mode is enabled:
+
+   * The cluster will automatically manage compute resources
+   * Node pools cannot be modified, only enabled or disabled
+   * EKS will handle scaling and management of the node pools
+3. Auto Mode requires specific IAM permissions. The construct will automatically attach the required managed policies.
+
 ### Managed node groups
 
 Amazon EKS managed node groups automate the provisioning and lifecycle management of nodes (Amazon EC2 instances) for Amazon EKS Kubernetes clusters.
@@ -108,15 +223,21 @@ With Amazon EKS managed node groups, you don't need to separately provision or r
 
 > For more details visit [Amazon EKS Managed Node Groups](https://docs.aws.amazon.com/eks/latest/userguide/managed-node-groups.html).
 
-**Managed Node Groups are the recommended way to allocate cluster capacity.**
+By default, when using `DefaultCapacityType.NODEGROUP`, this library will allocate a managed node group with 2 *m5.large* instances (this instance type suits most common use-cases, and is good value for money).
 
-By default, this library will allocate a managed node group with 2 *m5.large* instances (this instance type suits most common use-cases, and is good value for money).
+```python
+eks.Cluster(self, "HelloEKS",
+    version=eks.KubernetesVersion.V1_32,
+    default_capacity_type=eks.DefaultCapacityType.NODEGROUP
+)
+```
 
 At cluster instantiation time, you can customize the number of instances and their type:
 
 ```python
 eks.Cluster(self, "HelloEKS",
     version=eks.KubernetesVersion.V1_32,
+    default_capacity_type=eks.DefaultCapacityType.NODEGROUP,
     default_capacity=5,
     default_capacity_instance=ec2.InstanceType.of(ec2.InstanceClass.M5, ec2.InstanceSize.SMALL)
 )
@@ -129,6 +250,7 @@ Additional customizations are available post instantiation. To apply them, set t
 ```python
 cluster = eks.Cluster(self, "HelloEKS",
     version=eks.KubernetesVersion.V1_32,
+    default_capacity_type=eks.DefaultCapacityType.NODEGROUP,
     default_capacity=0
 )
 
@@ -4372,9 +4494,11 @@ class ClusterLoggingTypes(enum.Enum):
         "vpc": "vpc",
         "vpc_subnets": "vpcSubnets",
         "bootstrap_cluster_creator_admin_permissions": "bootstrapClusterCreatorAdminPermissions",
+        "compute": "compute",
         "default_capacity": "defaultCapacity",
         "default_capacity_instance": "defaultCapacityInstance",
         "default_capacity_type": "defaultCapacityType",
+        "output_config_command": "outputConfigCommand",
     },
 )
 class ClusterProps(ClusterCommonOptions):
@@ -4399,9 +4523,11 @@ class ClusterProps(ClusterCommonOptions):
         vpc: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc] = None,
         vpc_subnets: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection, typing.Dict[builtins.str, typing.Any]]]] = None,
         bootstrap_cluster_creator_admin_permissions: typing.Optional[builtins.bool] = None,
+        compute: typing.Optional[typing.Union["ComputeConfig", typing.Dict[builtins.str, typing.Any]]] = None,
         default_capacity: typing.Optional[jsii.Number] = None,
         default_capacity_instance: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.InstanceType] = None,
         default_capacity_type: typing.Optional["DefaultCapacityType"] = None,
+        output_config_command: typing.Optional[builtins.bool] = None,
     ) -> None:
         '''(experimental) Properties for configuring a standard EKS cluster (non-Fargate).
 
@@ -4423,30 +4549,31 @@ class ClusterProps(ClusterCommonOptions):
         :param vpc: (experimental) The VPC in which to create the Cluster. Default: - a VPC with default configuration will be created and can be accessed through ``cluster.vpc``.
         :param vpc_subnets: (experimental) Where to place EKS Control Plane ENIs. For example, to only select private subnets, supply the following: ``vpcSubnets: [{ subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS }]`` Default: - All public and private subnets
         :param bootstrap_cluster_creator_admin_permissions: (experimental) Whether or not IAM principal of the cluster creator was set as a cluster admin access entry during cluster creation time. Changing this value after the cluster has been created will result in the cluster being replaced. Default: true
+        :param compute: (experimental) Configuration for compute settings in Auto Mode. When enabled, EKS will automatically manage compute resources. Default: - Auto Mode compute disabled
         :param default_capacity: (experimental) Number of instances to allocate as an initial capacity for this cluster. Instance type can be configured through ``defaultCapacityInstanceType``, which defaults to ``m5.large``. Use ``cluster.addAutoScalingGroupCapacity`` to add additional customized capacity. Set this to ``0`` is you wish to avoid the initial capacity allocation. Default: 2
         :param default_capacity_instance: (experimental) The instance type to use for the default capacity. This will only be taken into account if ``defaultCapacity`` is > 0. Default: m5.large
         :param default_capacity_type: (experimental) The default capacity type for the cluster. Default: NODEGROUP
+        :param output_config_command: (experimental) Determines whether a CloudFormation output with the ``aws eks update-kubeconfig`` command will be synthesized. This command will include the cluster name and, if applicable, the ARN of the masters IAM role. Default: true
 
         :stability: experimental
         :exampleMetadata: infused
 
         Example::
 
-            cluster = eks.Cluster(self, "HelloEKS",
+            cluster = eks.Cluster(self, "EksAutoCluster",
                 version=eks.KubernetesVersion.V1_32,
-                default_capacity=0
-            )
-            
-            cluster.add_nodegroup_capacity("custom-node-group",
-                instance_types=[ec2.InstanceType("m5.large")],
-                min_size=4,
-                disk_size=100
+                default_capacity_type=eks.DefaultCapacityType.AUTOMODE,
+                compute=eks.ComputeConfig(
+                    node_pools=["system", "general-purpose"]
+                )
             )
         '''
         if isinstance(alb_controller, dict):
             alb_controller = AlbControllerOptions(**alb_controller)
         if isinstance(kubectl_provider_options, dict):
             kubectl_provider_options = KubectlProviderOptions(**kubectl_provider_options)
+        if isinstance(compute, dict):
+            compute = ComputeConfig(**compute)
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__cdebba88d00ede95b7f48fc97c266609fdb0fc0ef3bb709493d319c84ab460db)
             check_type(argname="argument version", value=version, expected_type=type_hints["version"])
@@ -4467,9 +4594,11 @@ class ClusterProps(ClusterCommonOptions):
             check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
             check_type(argname="argument vpc_subnets", value=vpc_subnets, expected_type=type_hints["vpc_subnets"])
             check_type(argname="argument bootstrap_cluster_creator_admin_permissions", value=bootstrap_cluster_creator_admin_permissions, expected_type=type_hints["bootstrap_cluster_creator_admin_permissions"])
+            check_type(argname="argument compute", value=compute, expected_type=type_hints["compute"])
             check_type(argname="argument default_capacity", value=default_capacity, expected_type=type_hints["default_capacity"])
             check_type(argname="argument default_capacity_instance", value=default_capacity_instance, expected_type=type_hints["default_capacity_instance"])
             check_type(argname="argument default_capacity_type", value=default_capacity_type, expected_type=type_hints["default_capacity_type"])
+            check_type(argname="argument output_config_command", value=output_config_command, expected_type=type_hints["output_config_command"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
             "version": version,
         }
@@ -4507,12 +4636,16 @@ class ClusterProps(ClusterCommonOptions):
             self._values["vpc_subnets"] = vpc_subnets
         if bootstrap_cluster_creator_admin_permissions is not None:
             self._values["bootstrap_cluster_creator_admin_permissions"] = bootstrap_cluster_creator_admin_permissions
+        if compute is not None:
+            self._values["compute"] = compute
         if default_capacity is not None:
             self._values["default_capacity"] = default_capacity
         if default_capacity_instance is not None:
             self._values["default_capacity_instance"] = default_capacity_instance
         if default_capacity_type is not None:
             self._values["default_capacity_type"] = default_capacity_type
+        if output_config_command is not None:
+            self._values["output_config_command"] = output_config_command
 
     @builtins.property
     def version(self) -> "KubernetesVersion":
@@ -4741,6 +4874,19 @@ class ClusterProps(ClusterCommonOptions):
         result = self._values.get("bootstrap_cluster_creator_admin_permissions")
         return typing.cast(typing.Optional[builtins.bool], result)
 
+    @builtins.property
+    def compute(self) -> typing.Optional["ComputeConfig"]:
+        '''(experimental) Configuration for compute settings in Auto Mode.
+
+        When enabled, EKS will automatically manage compute resources.
+
+        :default: - Auto Mode compute disabled
+
+        :stability: experimental
+        '''
+        result = self._values.get("compute")
+        return typing.cast(typing.Optional["ComputeConfig"], result)
+
     @builtins.property
     def default_capacity(self) -> typing.Optional[jsii.Number]:
         '''(experimental) Number of instances to allocate as an initial capacity for this cluster.
@@ -4785,6 +4931,20 @@ class ClusterProps(ClusterCommonOptions):
         result = self._values.get("default_capacity_type")
         return typing.cast(typing.Optional["DefaultCapacityType"], result)
 
+    @builtins.property
+    def output_config_command(self) -> typing.Optional[builtins.bool]:
+        '''(experimental) Determines whether a CloudFormation output with the ``aws eks update-kubeconfig`` command will be synthesized.
+
+        This command will include
+        the cluster name and, if applicable, the ARN of the masters IAM role.
+
+        :default: true
+
+        :stability: experimental
+        '''
+        result = self._values.get("output_config_command")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
     def __eq__(self, rhs: typing.Any) -> builtins.bool:
         return isinstance(rhs, self.__class__) and rhs._values == self._values
 
@@ -4797,6 +4957,87 @@ class ClusterProps(ClusterCommonOptions):
         )
 
 
+@jsii.data_type(
+    jsii_type="@aws-cdk/aws-eks-v2-alpha.ComputeConfig",
+    jsii_struct_bases=[],
+    name_mapping={"node_pools": "nodePools", "node_role": "nodeRole"},
+)
+class ComputeConfig:
+    def __init__(
+        self,
+        *,
+        node_pools: typing.Optional[typing.Sequence[builtins.str]] = None,
+        node_role: typing.Optional[_aws_cdk_aws_iam_ceddda9d.IRole] = None,
+    ) -> None:
+        '''(experimental) Options for configuring EKS Auto Mode compute settings.
+
+        When enabled, EKS will automatically manage compute resources like node groups and Fargate profiles.
+
+        :param node_pools: (experimental) Names of nodePools to include in Auto Mode. You cannot modify the built in system and general-purpose node pools. You can only enable or disable them. Node pool values are case-sensitive and must be ``general-purpose`` and/or ``system``. Default: - ['system', 'general-purpose']
+        :param node_role: (experimental) IAM role for the nodePools. Default: - generated by the CDK
+
+        :stability: experimental
+        :exampleMetadata: infused
+
+        Example::
+
+            cluster = eks.Cluster(self, "EksAutoCluster",
+                version=eks.KubernetesVersion.V1_32,
+                default_capacity_type=eks.DefaultCapacityType.AUTOMODE,
+                compute=eks.ComputeConfig(
+                    node_pools=["system", "general-purpose"]
+                )
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__ecd4e0b2b1c23fafd1f01982b69fda08d5f3b0615f7bf8fe543ae2d8e6784f6e)
+            check_type(argname="argument node_pools", value=node_pools, expected_type=type_hints["node_pools"])
+            check_type(argname="argument node_role", value=node_role, expected_type=type_hints["node_role"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if node_pools is not None:
+            self._values["node_pools"] = node_pools
+        if node_role is not None:
+            self._values["node_role"] = node_role
+
+    @builtins.property
+    def node_pools(self) -> typing.Optional[typing.List[builtins.str]]:
+        '''(experimental) Names of nodePools to include in Auto Mode.
+
+        You cannot modify the built in system and general-purpose node pools. You can only enable or disable them.
+        Node pool values are case-sensitive and must be ``general-purpose`` and/or ``system``.
+
+        :default: - ['system', 'general-purpose']
+
+        :see: - https://docs.aws.amazon.com/eks/latest/userguide/create-node-pool.html
+        :stability: experimental
+        '''
+        result = self._values.get("node_pools")
+        return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+    @builtins.property
+    def node_role(self) -> typing.Optional[_aws_cdk_aws_iam_ceddda9d.IRole]:
+        '''(experimental) IAM role for the nodePools.
+
+        :default: - generated by the CDK
+
+        :see: - https://docs.aws.amazon.com/eks/latest/userguide/create-node-role.html
+        :stability: experimental
+        '''
+        result = self._values.get("node_role")
+        return typing.cast(typing.Optional[_aws_cdk_aws_iam_ceddda9d.IRole], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "ComputeConfig(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.enum(jsii_type="@aws-cdk/aws-eks-v2-alpha.CoreDnsComputeType")
 class CoreDnsComputeType(enum.Enum):
     '''(experimental) The type of compute resources to use for CoreDNS.
@@ -4840,6 +5081,21 @@ class DefaultCapacityType(enum.Enum):
     '''(experimental) The default capacity type for the cluster.
 
     :stability: experimental
+    :exampleMetadata: infused
+
+    Example::
+
+        cluster = eks.Cluster(self, "HelloEKS",
+            version=eks.KubernetesVersion.V1_32,
+            default_capacity_type=eks.DefaultCapacityType.NODEGROUP,
+            default_capacity=0
+        )
+        
+        cluster.add_nodegroup_capacity("custom-node-group",
+            instance_types=[ec2.InstanceType("m5.large")],
+            min_size=4,
+            disk_size=100
+        )
     '''
 
     NODEGROUP = "NODEGROUP"
@@ -4852,6 +5108,11 @@ class DefaultCapacityType(enum.Enum):
 
     :stability: experimental
     '''
+    AUTOMODE = "AUTOMODE"
+    '''(experimental) Auto Mode.
+
+    :stability: experimental
+    '''
 
 
 @jsii.implements(_aws_cdk_aws_ec2_ceddda9d.IMachineImage)
@@ -9167,9 +9428,12 @@ class KubernetesVersion(
 
     Example::
 
-        cluster = eks.Cluster(self, "hello-eks",
+        cluster = eks.Cluster(self, "EksAutoCluster",
             version=eks.KubernetesVersion.V1_32,
-            endpoint_access=eks.EndpointAccess.PRIVATE
+            default_capacity_type=eks.DefaultCapacityType.AUTOMODE,
+            compute=eks.ComputeConfig(
+                node_pools=["system", "general-purpose"]
+            )
         )
     '''
 
@@ -9822,6 +10086,7 @@ class NodegroupOptions:
 
             cluster = eks.Cluster(self, "HelloEKS",
                 version=eks.KubernetesVersion.V1_32,
+                default_capacity_type=eks.DefaultCapacityType.NODEGROUP,
                 default_capacity=0
             )
             
@@ -12049,15 +12314,12 @@ class Cluster(
 
     Example::
 
-        cluster = eks.Cluster(self, "HelloEKS",
+        cluster = eks.Cluster(self, "EksAutoCluster",
             version=eks.KubernetesVersion.V1_32,
-            default_capacity=0
-        )
-        
-        cluster.add_nodegroup_capacity("custom-node-group",
-            instance_types=[ec2.InstanceType("m5.large")],
-            min_size=4,
-            disk_size=100
+            default_capacity_type=eks.DefaultCapacityType.AUTOMODE,
+            compute=eks.ComputeConfig(
+                node_pools=["system", "general-purpose"]
+            )
         )
     '''
 
@@ -12067,9 +12329,11 @@ class Cluster(
         id: builtins.str,
         *,
         bootstrap_cluster_creator_admin_permissions: typing.Optional[builtins.bool] = None,
+        compute: typing.Optional[typing.Union[ComputeConfig, typing.Dict[builtins.str, typing.Any]]] = None,
         default_capacity: typing.Optional[jsii.Number] = None,
         default_capacity_instance: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.InstanceType] = None,
         default_capacity_type: typing.Optional[DefaultCapacityType] = None,
+        output_config_command: typing.Optional[builtins.bool] = None,
         version: KubernetesVersion,
         alb_controller: typing.Optional[typing.Union[AlbControllerOptions, typing.Dict[builtins.str, typing.Any]]] = None,
         cluster_logging: typing.Optional[typing.Sequence[ClusterLoggingTypes]] = None,
@@ -12093,9 +12357,11 @@ class Cluster(
         :param scope: a Construct, most likely a cdk.Stack created.
         :param id: the id of the Construct to create.
         :param bootstrap_cluster_creator_admin_permissions: (experimental) Whether or not IAM principal of the cluster creator was set as a cluster admin access entry during cluster creation time. Changing this value after the cluster has been created will result in the cluster being replaced. Default: true
+        :param compute: (experimental) Configuration for compute settings in Auto Mode. When enabled, EKS will automatically manage compute resources. Default: - Auto Mode compute disabled
         :param default_capacity: (experimental) Number of instances to allocate as an initial capacity for this cluster. Instance type can be configured through ``defaultCapacityInstanceType``, which defaults to ``m5.large``. Use ``cluster.addAutoScalingGroupCapacity`` to add additional customized capacity. Set this to ``0`` is you wish to avoid the initial capacity allocation. Default: 2
         :param default_capacity_instance: (experimental) The instance type to use for the default capacity. This will only be taken into account if ``defaultCapacity`` is > 0. Default: m5.large
         :param default_capacity_type: (experimental) The default capacity type for the cluster. Default: NODEGROUP
+        :param output_config_command: (experimental) Determines whether a CloudFormation output with the ``aws eks update-kubeconfig`` command will be synthesized. This command will include the cluster name and, if applicable, the ARN of the masters IAM role. Default: true
         :param version: (experimental) The Kubernetes version to run in the cluster.
         :param alb_controller: (experimental) Install the AWS Load Balancer Controller onto the cluster. Default: - The controller is not installed.
         :param cluster_logging: (experimental) The cluster log types which you want to enable. Default: - none
@@ -12122,9 +12388,11 @@ class Cluster(
             check_type(argname="argument id", value=id, expected_type=type_hints["id"])
         props = ClusterProps(
             bootstrap_cluster_creator_admin_permissions=bootstrap_cluster_creator_admin_permissions,
+            compute=compute,
             default_capacity=default_capacity,
             default_capacity_instance=default_capacity_instance,
             default_capacity_type=default_capacity_type,
+            output_config_command=output_config_command,
             version=version,
             alb_controller=alb_controller,
             cluster_logging=cluster_logging,
@@ -13137,6 +13405,7 @@ __all__ = [
     "ClusterCommonOptions",
     "ClusterLoggingTypes",
     "ClusterProps",
+    "ComputeConfig",
     "CoreDnsComputeType",
     "CpuArch",
     "DefaultCapacityType",
@@ -13436,9 +13705,19 @@ def _typecheckingstub__cdebba88d00ede95b7f48fc97c266609fdb0fc0ef3bb709493d319c84
     vpc: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.IVpc] = None,
     vpc_subnets: typing.Optional[typing.Sequence[typing.Union[_aws_cdk_aws_ec2_ceddda9d.SubnetSelection, typing.Dict[builtins.str, typing.Any]]]] = None,
     bootstrap_cluster_creator_admin_permissions: typing.Optional[builtins.bool] = None,
+    compute: typing.Optional[typing.Union[ComputeConfig, typing.Dict[builtins.str, typing.Any]]] = None,
     default_capacity: typing.Optional[jsii.Number] = None,
     default_capacity_instance: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.InstanceType] = None,
     default_capacity_type: typing.Optional[DefaultCapacityType] = None,
+    output_config_command: typing.Optional[builtins.bool] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__ecd4e0b2b1c23fafd1f01982b69fda08d5f3b0615f7bf8fe543ae2d8e6784f6e(
+    *,
+    node_pools: typing.Optional[typing.Sequence[builtins.str]] = None,
+    node_role: typing.Optional[_aws_cdk_aws_iam_ceddda9d.IRole] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -14076,9 +14355,11 @@ def _typecheckingstub__f953a3ebdf317cd4c17c2caf66c079973022b58e6c5cf124f9d5f0089
     id: builtins.str,
     *,
     bootstrap_cluster_creator_admin_permissions: typing.Optional[builtins.bool] = None,
+    compute: typing.Optional[typing.Union[ComputeConfig, typing.Dict[builtins.str, typing.Any]]] = None,
     default_capacity: typing.Optional[jsii.Number] = None,
     default_capacity_instance: typing.Optional[_aws_cdk_aws_ec2_ceddda9d.InstanceType] = None,
     default_capacity_type: typing.Optional[DefaultCapacityType] = None,
+    output_config_command: typing.Optional[builtins.bool] = None,
     version: KubernetesVersion,
     alb_controller: typing.Optional[typing.Union[AlbControllerOptions, typing.Dict[builtins.str, typing.Any]]] = None,
     cluster_logging: typing.Optional[typing.Sequence[ClusterLoggingTypes]] = None,

{aws_cdk_aws_eks_v2_alpha-2.180.0a0 → aws_cdk_aws_eks_v2_alpha-2.181.1a0}/src/aws_cdk/aws_eks_v2_alpha/_jsii/__init__.py

@@ -33,9 +33,9 @@ import constructs._jsii
 
 __jsii_assembly__ = jsii.JSIIAssembly.load(
     "@aws-cdk/aws-eks-v2-alpha",
-    "2.180.0-alpha.0",
+    "2.181.1-alpha.0",
     __name__[0:-6],
-    "aws-eks-v2-alpha@2.180.0-alpha.0.jsii.tgz",
+    "aws-eks-v2-alpha@2.181.1-alpha.0.jsii.tgz",
 )
 
 __all__ = [

{aws_cdk_aws_eks_v2_alpha-2.180.0a0 → aws_cdk_aws_eks_v2_alpha-2.181.1a0/src/aws_cdk.aws_eks_v2_alpha.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: aws-cdk.aws-eks-v2-alpha
-Version: 2.180.0a0
+Version: 2.181.1a0
 Summary: The CDK Construct Library for AWS::EKS
 Home-page: https://github.com/aws/aws-cdk
 Author: Amazon Web Services
@@ -23,7 +23,7 @@ Requires-Python: ~=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: NOTICE
-Requires-Dist: aws-cdk-lib<3.0.0,>=2.180.0
+Requires-Dist: aws-cdk-lib<3.0.0,>=2.181.1
 Requires-Dist: constructs<11.0.0,>=10.0.0
 Requires-Dist: jsii<2.0.0,>=1.106.0
 Requires-Dist: publication>=0.0.3
@@ -131,6 +131,121 @@ eks.Cluster(self, "hello-eks",
 )
 ```
 
+## EKS Auto Mode
+
+[Amazon EKS Auto Mode](https://aws.amazon.com/eks/auto-mode/) extends AWS management of Kubernetes clusters beyond the cluster itself, allowing AWS to set up and manage the infrastructure that enables the smooth operation of your workloads.
+
+### Using Auto Mode
+
+While `aws-eks` uses `DefaultCapacityType.NODEGROUP` by default, `aws-eks-v2` uses `DefaultCapacityType.AUTOMODE` as the default capacity type.
+
+Auto Mode is enabled by default when creating a new cluster without specifying any capacity-related properties:
+
+```python
+# Create EKS cluster with Auto Mode implicitly enabled
+cluster = eks.Cluster(self, "EksAutoCluster",
+    version=eks.KubernetesVersion.V1_32
+)
+```
+
+You can also explicitly enable Auto Mode using `defaultCapacityType`:
+
+```python
+# Create EKS cluster with Auto Mode explicitly enabled
+cluster = eks.Cluster(self, "EksAutoCluster",
+    version=eks.KubernetesVersion.V1_32,
+    default_capacity_type=eks.DefaultCapacityType.AUTOMODE
+)
+```
+
+### Node Pools
+
+When Auto Mode is enabled, the cluster comes with two default node pools:
+
+* `system`: For running system components and add-ons
+* `general-purpose`: For running your application workloads
+
+These node pools are managed automatically by EKS. You can configure which node pools to enable through the `compute` property:
+
+```python
+cluster = eks.Cluster(self, "EksAutoCluster",
+    version=eks.KubernetesVersion.V1_32,
+    default_capacity_type=eks.DefaultCapacityType.AUTOMODE,
+    compute=eks.ComputeConfig(
+        node_pools=["system", "general-purpose"]
+    )
+)
+```
+
+For more information, see [Create a Node Pool for EKS Auto Mode](https://docs.aws.amazon.com/eks/latest/userguide/create-node-pool.html).
+
+### Node Groups as the default capacity type
+
+If you prefer to manage your own node groups instead of using Auto Mode, you can use the traditional node group approach by specifying `defaultCapacityType` as `NODEGROUP`:
+
+```python
+# Create EKS cluster with traditional managed node group
+cluster = eks.Cluster(self, "EksCluster",
+    version=eks.KubernetesVersion.V1_32,
+    default_capacity_type=eks.DefaultCapacityType.NODEGROUP,
+    default_capacity=3,  # Number of instances
+    default_capacity_instance=ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.LARGE)
+)
+```
+
+You can also create a cluster with no initial capacity and add node groups later:
+
+```python
+cluster = eks.Cluster(self, "EksCluster",
+    version=eks.KubernetesVersion.V1_32,
+    default_capacity_type=eks.DefaultCapacityType.NODEGROUP,
+    default_capacity=0
+)
+
+# Add node groups as needed
+cluster.add_nodegroup_capacity("custom-node-group",
+    min_size=1,
+    max_size=3,
+    instance_types=[ec2.InstanceType.of(ec2.InstanceClass.T3, ec2.InstanceSize.LARGE)]
+)
+```
+
+Read [Managed node groups](#managed-node-groups) for more information on how to add node groups to the cluster.
+
+### Mixed with Auto Mode and Node Groups
+
+You can combine Auto Mode with traditional node groups for specific workload requirements:
+
+```python
+cluster = eks.Cluster(self, "Cluster",
+    version=eks.KubernetesVersion.V1_32,
+    default_capacity_type=eks.DefaultCapacityType.AUTOMODE,
+    compute=eks.ComputeConfig(
+        node_pools=["system", "general-purpose"]
+    )
+)
+
+# Add specialized node group for specific workloads
+cluster.add_nodegroup_capacity("specialized-workload",
+    min_size=1,
+    max_size=3,
+    instance_types=[ec2.InstanceType.of(ec2.InstanceClass.C5, ec2.InstanceSize.XLARGE)],
+    labels={
+        "workload": "specialized"
+    }
+)
+```
+
+### Important Notes
+
+1. Auto Mode and traditional capacity management are mutually exclusive at the default capacity level. You cannot opt in to Auto Mode and specify `defaultCapacity` or `defaultCapacityInstance`.
+2. When Auto Mode is enabled:
+
+   * The cluster will automatically manage compute resources
+   * Node pools cannot be modified, only enabled or disabled
+   * EKS will handle scaling and management of the node pools
+3. Auto Mode requires specific IAM permissions. The construct will automatically attach the required managed policies.
+
 ### Managed node groups
 
 Amazon EKS managed node groups automate the provisioning and lifecycle management of nodes (Amazon EC2 instances) for Amazon EKS Kubernetes clusters.
@@ -138,15 +253,21 @@ With Amazon EKS managed node groups, you don't need to separately provision or r
 
 > For more details visit [Amazon EKS Managed Node Groups](https://docs.aws.amazon.com/eks/latest/userguide/managed-node-groups.html).
 
-**Managed Node Groups are the recommended way to allocate cluster capacity.**
+By default, when using `DefaultCapacityType.NODEGROUP`, this library will allocate a managed node group with 2 *m5.large* instances (this instance type suits most common use-cases, and is good value for money).
 
-By default, this library will allocate a managed node group with 2 *m5.large* instances (this instance type suits most common use-cases, and is good value for money).
+```python
+eks.Cluster(self, "HelloEKS",
+    version=eks.KubernetesVersion.V1_32,
+    default_capacity_type=eks.DefaultCapacityType.NODEGROUP
+)
+```
 
 At cluster instantiation time, you can customize the number of instances and their type:
 
 ```python
 eks.Cluster(self, "HelloEKS",
     version=eks.KubernetesVersion.V1_32,
+    default_capacity_type=eks.DefaultCapacityType.NODEGROUP,
     default_capacity=5,
     default_capacity_instance=ec2.InstanceType.of(ec2.InstanceClass.M5, ec2.InstanceSize.SMALL)
 )
@@ -159,6 +280,7 @@ Additional customizations are available post instantiation. To apply them, set t
 ```python
 cluster = eks.Cluster(self, "HelloEKS",
     version=eks.KubernetesVersion.V1_32,
+    default_capacity_type=eks.DefaultCapacityType.NODEGROUP,
     default_capacity=0
 )
 

{aws_cdk_aws_eks_v2_alpha-2.180.0a0 → aws_cdk_aws_eks_v2_alpha-2.181.1a0}/src/aws_cdk.aws_eks_v2_alpha.egg-info/SOURCES.txt

@@ -12,4 +12,4 @@ src/aws_cdk.aws_eks_v2_alpha.egg-info/top_level.txt
 src/aws_cdk/aws_eks_v2_alpha/__init__.py
 src/aws_cdk/aws_eks_v2_alpha/py.typed
 src/aws_cdk/aws_eks_v2_alpha/_jsii/__init__.py
-src/aws_cdk/aws_eks_v2_alpha/_jsii/aws-eks-v2-alpha@2.180.0-alpha.0.jsii.tgz
+src/aws_cdk/aws_eks_v2_alpha/_jsii/aws-eks-v2-alpha@2.181.1-alpha.0.jsii.tgz

{aws_cdk_aws_eks_v2_alpha-2.180.0a0 → aws_cdk_aws_eks_v2_alpha-2.181.1a0}/src/aws_cdk.aws_eks_v2_alpha.egg-info/requires.txt

@@ -1,4 +1,4 @@
-aws-cdk-lib<3.0.0,>=2.180.0
+aws-cdk-lib<3.0.0,>=2.181.1
 constructs<11.0.0,>=10.0.0
 jsii<2.0.0,>=1.106.0
 publication>=0.0.3