1. Packages
  2. Google Cloud (GCP) Classic
  3. API Docs
  4. container
  5. AwsNodePool
Google Cloud Classic v7.26.0 published on Friday, Jun 7, 2024 by Pulumi

gcp.container.AwsNodePool

Explore with Pulumi AI

gcp logo
Google Cloud Classic v7.26.0 published on Friday, Jun 7, 2024 by Pulumi

    An Anthos node pool running on AWS.

    For more information, see:

    Example Usage

    Basic_aws_cluster

    A basic example of a containeraws node pool

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    
    const versions = gcp.container.getAwsVersions({
        project: "my-project-name",
        location: "us-west1",
    });
    const primary = new gcp.container.AwsCluster("primary", {
        authorization: {
            adminUsers: [{
                username: "my@service-account.com",
            }],
        },
        awsRegion: "my-aws-region",
        controlPlane: {
            awsServicesAuthentication: {
                roleArn: "arn:aws:iam::012345678910:role/my--1p-dev-oneplatform",
                roleSessionName: "my--1p-dev-session",
            },
            configEncryption: {
                kmsKeyArn: "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
            },
            databaseEncryption: {
                kmsKeyArn: "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
            },
            iamInstanceProfile: "my--1p-dev-controlplane",
            subnetIds: ["subnet-00000000000000000"],
            version: versions.then(versions => versions.validVersions?.[0]),
            instanceType: "t3.medium",
            mainVolume: {
                iops: 3000,
                kmsKeyArn: "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                sizeGib: 10,
                volumeType: "GP3",
            },
            proxyConfig: {
                secretArn: "arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF",
                secretVersion: "12345678-ABCD-EFGH-IJKL-987654321098",
            },
            rootVolume: {
                iops: 3000,
                kmsKeyArn: "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                sizeGib: 10,
                volumeType: "GP3",
            },
            securityGroupIds: ["sg-00000000000000000"],
            sshConfig: {
                ec2KeyPair: "my--1p-dev-ssh",
            },
            tags: {
                owner: "my@service-account.com",
            },
        },
        fleet: {
            project: "my-project-number",
        },
        location: "us-west1",
        name: "name",
        networking: {
            podAddressCidrBlocks: ["10.2.0.0/16"],
            serviceAddressCidrBlocks: ["10.1.0.0/16"],
            vpcId: "vpc-00000000000000000",
        },
        annotations: {
            "label-one": "value-one",
        },
        description: "A sample aws cluster",
        project: "my-project-name",
    });
    const primaryAwsNodePool = new gcp.container.AwsNodePool("primary", {
        autoscaling: {
            maxNodeCount: 5,
            minNodeCount: 1,
        },
        cluster: primary.name,
        config: {
            configEncryption: {
                kmsKeyArn: "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
            },
            iamInstanceProfile: "my--1p-dev-nodepool",
            instanceType: "t3.medium",
            labels: {
                "label-one": "value-one",
            },
            rootVolume: {
                iops: 3000,
                kmsKeyArn: "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                sizeGib: 10,
                volumeType: "GP3",
            },
            securityGroupIds: ["sg-00000000000000000"],
            proxyConfig: {
                secretArn: "arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF",
                secretVersion: "12345678-ABCD-EFGH-IJKL-987654321098",
            },
            sshConfig: {
                ec2KeyPair: "my--1p-dev-ssh",
            },
            tags: {
                "tag-one": "value-one",
            },
            taints: [{
                effect: "PREFER_NO_SCHEDULE",
                key: "taint-key",
                value: "taint-value",
            }],
        },
        location: "us-west1",
        maxPodsConstraint: {
            maxPodsPerNode: 110,
        },
        name: "node-pool-name",
        subnetId: "subnet-00000000000000000",
        version: versions.then(versions => versions.validVersions?.[0]),
        annotations: {
            "label-one": "value-one",
        },
        management: {
            autoRepair: true,
        },
        project: "my-project-name",
    });
    
    import pulumi
    import pulumi_gcp as gcp
    
    versions = gcp.container.get_aws_versions(project="my-project-name",
        location="us-west1")
    primary = gcp.container.AwsCluster("primary",
        authorization=gcp.container.AwsClusterAuthorizationArgs(
            admin_users=[gcp.container.AwsClusterAuthorizationAdminUserArgs(
                username="my@service-account.com",
            )],
        ),
        aws_region="my-aws-region",
        control_plane=gcp.container.AwsClusterControlPlaneArgs(
            aws_services_authentication=gcp.container.AwsClusterControlPlaneAwsServicesAuthenticationArgs(
                role_arn="arn:aws:iam::012345678910:role/my--1p-dev-oneplatform",
                role_session_name="my--1p-dev-session",
            ),
            config_encryption=gcp.container.AwsClusterControlPlaneConfigEncryptionArgs(
                kms_key_arn="arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
            ),
            database_encryption=gcp.container.AwsClusterControlPlaneDatabaseEncryptionArgs(
                kms_key_arn="arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
            ),
            iam_instance_profile="my--1p-dev-controlplane",
            subnet_ids=["subnet-00000000000000000"],
            version=versions.valid_versions[0],
            instance_type="t3.medium",
            main_volume=gcp.container.AwsClusterControlPlaneMainVolumeArgs(
                iops=3000,
                kms_key_arn="arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                size_gib=10,
                volume_type="GP3",
            ),
            proxy_config=gcp.container.AwsClusterControlPlaneProxyConfigArgs(
                secret_arn="arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF",
                secret_version="12345678-ABCD-EFGH-IJKL-987654321098",
            ),
            root_volume=gcp.container.AwsClusterControlPlaneRootVolumeArgs(
                iops=3000,
                kms_key_arn="arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                size_gib=10,
                volume_type="GP3",
            ),
            security_group_ids=["sg-00000000000000000"],
            ssh_config=gcp.container.AwsClusterControlPlaneSshConfigArgs(
                ec2_key_pair="my--1p-dev-ssh",
            ),
            tags={
                "owner": "my@service-account.com",
            },
        ),
        fleet=gcp.container.AwsClusterFleetArgs(
            project="my-project-number",
        ),
        location="us-west1",
        name="name",
        networking=gcp.container.AwsClusterNetworkingArgs(
            pod_address_cidr_blocks=["10.2.0.0/16"],
            service_address_cidr_blocks=["10.1.0.0/16"],
            vpc_id="vpc-00000000000000000",
        ),
        annotations={
            "label-one": "value-one",
        },
        description="A sample aws cluster",
        project="my-project-name")
    primary_aws_node_pool = gcp.container.AwsNodePool("primary",
        autoscaling=gcp.container.AwsNodePoolAutoscalingArgs(
            max_node_count=5,
            min_node_count=1,
        ),
        cluster=primary.name,
        config=gcp.container.AwsNodePoolConfigArgs(
            config_encryption=gcp.container.AwsNodePoolConfigConfigEncryptionArgs(
                kms_key_arn="arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
            ),
            iam_instance_profile="my--1p-dev-nodepool",
            instance_type="t3.medium",
            labels={
                "label-one": "value-one",
            },
            root_volume=gcp.container.AwsNodePoolConfigRootVolumeArgs(
                iops=3000,
                kms_key_arn="arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                size_gib=10,
                volume_type="GP3",
            ),
            security_group_ids=["sg-00000000000000000"],
            proxy_config=gcp.container.AwsNodePoolConfigProxyConfigArgs(
                secret_arn="arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF",
                secret_version="12345678-ABCD-EFGH-IJKL-987654321098",
            ),
            ssh_config=gcp.container.AwsNodePoolConfigSshConfigArgs(
                ec2_key_pair="my--1p-dev-ssh",
            ),
            tags={
                "tag-one": "value-one",
            },
            taints=[gcp.container.AwsNodePoolConfigTaintArgs(
                effect="PREFER_NO_SCHEDULE",
                key="taint-key",
                value="taint-value",
            )],
        ),
        location="us-west1",
        max_pods_constraint=gcp.container.AwsNodePoolMaxPodsConstraintArgs(
            max_pods_per_node=110,
        ),
        name="node-pool-name",
        subnet_id="subnet-00000000000000000",
        version=versions.valid_versions[0],
        annotations={
            "label-one": "value-one",
        },
        management=gcp.container.AwsNodePoolManagementArgs(
            auto_repair=True,
        ),
        project="my-project-name")
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/container"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		versions, err := container.GetAwsVersions(ctx, &container.GetAwsVersionsArgs{
    			Project:  pulumi.StringRef("my-project-name"),
    			Location: pulumi.StringRef("us-west1"),
    		}, nil)
    		if err != nil {
    			return err
    		}
    		primary, err := container.NewAwsCluster(ctx, "primary", &container.AwsClusterArgs{
    			Authorization: &container.AwsClusterAuthorizationArgs{
    				AdminUsers: container.AwsClusterAuthorizationAdminUserArray{
    					&container.AwsClusterAuthorizationAdminUserArgs{
    						Username: pulumi.String("my@service-account.com"),
    					},
    				},
    			},
    			AwsRegion: pulumi.String("my-aws-region"),
    			ControlPlane: &container.AwsClusterControlPlaneArgs{
    				AwsServicesAuthentication: &container.AwsClusterControlPlaneAwsServicesAuthenticationArgs{
    					RoleArn:         pulumi.String("arn:aws:iam::012345678910:role/my--1p-dev-oneplatform"),
    					RoleSessionName: pulumi.String("my--1p-dev-session"),
    				},
    				ConfigEncryption: &container.AwsClusterControlPlaneConfigEncryptionArgs{
    					KmsKeyArn: pulumi.String("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111"),
    				},
    				DatabaseEncryption: &container.AwsClusterControlPlaneDatabaseEncryptionArgs{
    					KmsKeyArn: pulumi.String("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111"),
    				},
    				IamInstanceProfile: pulumi.String("my--1p-dev-controlplane"),
    				SubnetIds: pulumi.StringArray{
    					pulumi.String("subnet-00000000000000000"),
    				},
    				Version:      pulumi.String(versions.ValidVersions[0]),
    				InstanceType: pulumi.String("t3.medium"),
    				MainVolume: &container.AwsClusterControlPlaneMainVolumeArgs{
    					Iops:       pulumi.Int(3000),
    					KmsKeyArn:  pulumi.String("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111"),
    					SizeGib:    pulumi.Int(10),
    					VolumeType: pulumi.String("GP3"),
    				},
    				ProxyConfig: &container.AwsClusterControlPlaneProxyConfigArgs{
    					SecretArn:     pulumi.String("arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF"),
    					SecretVersion: pulumi.String("12345678-ABCD-EFGH-IJKL-987654321098"),
    				},
    				RootVolume: &container.AwsClusterControlPlaneRootVolumeArgs{
    					Iops:       pulumi.Int(3000),
    					KmsKeyArn:  pulumi.String("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111"),
    					SizeGib:    pulumi.Int(10),
    					VolumeType: pulumi.String("GP3"),
    				},
    				SecurityGroupIds: pulumi.StringArray{
    					pulumi.String("sg-00000000000000000"),
    				},
    				SshConfig: &container.AwsClusterControlPlaneSshConfigArgs{
    					Ec2KeyPair: pulumi.String("my--1p-dev-ssh"),
    				},
    				Tags: pulumi.StringMap{
    					"owner": pulumi.String("my@service-account.com"),
    				},
    			},
    			Fleet: &container.AwsClusterFleetArgs{
    				Project: pulumi.String("my-project-number"),
    			},
    			Location: pulumi.String("us-west1"),
    			Name:     pulumi.String("name"),
    			Networking: &container.AwsClusterNetworkingArgs{
    				PodAddressCidrBlocks: pulumi.StringArray{
    					pulumi.String("10.2.0.0/16"),
    				},
    				ServiceAddressCidrBlocks: pulumi.StringArray{
    					pulumi.String("10.1.0.0/16"),
    				},
    				VpcId: pulumi.String("vpc-00000000000000000"),
    			},
    			Annotations: pulumi.StringMap{
    				"label-one": pulumi.String("value-one"),
    			},
    			Description: pulumi.String("A sample aws cluster"),
    			Project:     pulumi.String("my-project-name"),
    		})
    		if err != nil {
    			return err
    		}
    		_, err = container.NewAwsNodePool(ctx, "primary", &container.AwsNodePoolArgs{
    			Autoscaling: &container.AwsNodePoolAutoscalingArgs{
    				MaxNodeCount: pulumi.Int(5),
    				MinNodeCount: pulumi.Int(1),
    			},
    			Cluster: primary.Name,
    			Config: &container.AwsNodePoolConfigArgs{
    				ConfigEncryption: &container.AwsNodePoolConfigConfigEncryptionArgs{
    					KmsKeyArn: pulumi.String("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111"),
    				},
    				IamInstanceProfile: pulumi.String("my--1p-dev-nodepool"),
    				InstanceType:       pulumi.String("t3.medium"),
    				Labels: pulumi.StringMap{
    					"label-one": pulumi.String("value-one"),
    				},
    				RootVolume: &container.AwsNodePoolConfigRootVolumeArgs{
    					Iops:       pulumi.Int(3000),
    					KmsKeyArn:  pulumi.String("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111"),
    					SizeGib:    pulumi.Int(10),
    					VolumeType: pulumi.String("GP3"),
    				},
    				SecurityGroupIds: pulumi.StringArray{
    					pulumi.String("sg-00000000000000000"),
    				},
    				ProxyConfig: &container.AwsNodePoolConfigProxyConfigArgs{
    					SecretArn:     pulumi.String("arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF"),
    					SecretVersion: pulumi.String("12345678-ABCD-EFGH-IJKL-987654321098"),
    				},
    				SshConfig: &container.AwsNodePoolConfigSshConfigArgs{
    					Ec2KeyPair: pulumi.String("my--1p-dev-ssh"),
    				},
    				Tags: pulumi.StringMap{
    					"tag-one": pulumi.String("value-one"),
    				},
    				Taints: container.AwsNodePoolConfigTaintArray{
    					&container.AwsNodePoolConfigTaintArgs{
    						Effect: pulumi.String("PREFER_NO_SCHEDULE"),
    						Key:    pulumi.String("taint-key"),
    						Value:  pulumi.String("taint-value"),
    					},
    				},
    			},
    			Location: pulumi.String("us-west1"),
    			MaxPodsConstraint: &container.AwsNodePoolMaxPodsConstraintArgs{
    				MaxPodsPerNode: pulumi.Int(110),
    			},
    			Name:     pulumi.String("node-pool-name"),
    			SubnetId: pulumi.String("subnet-00000000000000000"),
    			Version:  pulumi.String(versions.ValidVersions[0]),
    			Annotations: pulumi.StringMap{
    				"label-one": pulumi.String("value-one"),
    			},
    			Management: &container.AwsNodePoolManagementArgs{
    				AutoRepair: pulumi.Bool(true),
    			},
    			Project: pulumi.String("my-project-name"),
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Gcp = Pulumi.Gcp;
    
    return await Deployment.RunAsync(() => 
    {
        var versions = Gcp.Container.GetAwsVersions.Invoke(new()
        {
            Project = "my-project-name",
            Location = "us-west1",
        });
    
        var primary = new Gcp.Container.AwsCluster("primary", new()
        {
            Authorization = new Gcp.Container.Inputs.AwsClusterAuthorizationArgs
            {
                AdminUsers = new[]
                {
                    new Gcp.Container.Inputs.AwsClusterAuthorizationAdminUserArgs
                    {
                        Username = "my@service-account.com",
                    },
                },
            },
            AwsRegion = "my-aws-region",
            ControlPlane = new Gcp.Container.Inputs.AwsClusterControlPlaneArgs
            {
                AwsServicesAuthentication = new Gcp.Container.Inputs.AwsClusterControlPlaneAwsServicesAuthenticationArgs
                {
                    RoleArn = "arn:aws:iam::012345678910:role/my--1p-dev-oneplatform",
                    RoleSessionName = "my--1p-dev-session",
                },
                ConfigEncryption = new Gcp.Container.Inputs.AwsClusterControlPlaneConfigEncryptionArgs
                {
                    KmsKeyArn = "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                },
                DatabaseEncryption = new Gcp.Container.Inputs.AwsClusterControlPlaneDatabaseEncryptionArgs
                {
                    KmsKeyArn = "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                },
                IamInstanceProfile = "my--1p-dev-controlplane",
                SubnetIds = new[]
                {
                    "subnet-00000000000000000",
                },
                Version = versions.Apply(getAwsVersionsResult => getAwsVersionsResult.ValidVersions[0]),
                InstanceType = "t3.medium",
                MainVolume = new Gcp.Container.Inputs.AwsClusterControlPlaneMainVolumeArgs
                {
                    Iops = 3000,
                    KmsKeyArn = "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                    SizeGib = 10,
                    VolumeType = "GP3",
                },
                ProxyConfig = new Gcp.Container.Inputs.AwsClusterControlPlaneProxyConfigArgs
                {
                    SecretArn = "arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF",
                    SecretVersion = "12345678-ABCD-EFGH-IJKL-987654321098",
                },
                RootVolume = new Gcp.Container.Inputs.AwsClusterControlPlaneRootVolumeArgs
                {
                    Iops = 3000,
                    KmsKeyArn = "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                    SizeGib = 10,
                    VolumeType = "GP3",
                },
                SecurityGroupIds = new[]
                {
                    "sg-00000000000000000",
                },
                SshConfig = new Gcp.Container.Inputs.AwsClusterControlPlaneSshConfigArgs
                {
                    Ec2KeyPair = "my--1p-dev-ssh",
                },
                Tags = 
                {
                    { "owner", "my@service-account.com" },
                },
            },
            Fleet = new Gcp.Container.Inputs.AwsClusterFleetArgs
            {
                Project = "my-project-number",
            },
            Location = "us-west1",
            Name = "name",
            Networking = new Gcp.Container.Inputs.AwsClusterNetworkingArgs
            {
                PodAddressCidrBlocks = new[]
                {
                    "10.2.0.0/16",
                },
                ServiceAddressCidrBlocks = new[]
                {
                    "10.1.0.0/16",
                },
                VpcId = "vpc-00000000000000000",
            },
            Annotations = 
            {
                { "label-one", "value-one" },
            },
            Description = "A sample aws cluster",
            Project = "my-project-name",
        });
    
        var primaryAwsNodePool = new Gcp.Container.AwsNodePool("primary", new()
        {
            Autoscaling = new Gcp.Container.Inputs.AwsNodePoolAutoscalingArgs
            {
                MaxNodeCount = 5,
                MinNodeCount = 1,
            },
            Cluster = primary.Name,
            Config = new Gcp.Container.Inputs.AwsNodePoolConfigArgs
            {
                ConfigEncryption = new Gcp.Container.Inputs.AwsNodePoolConfigConfigEncryptionArgs
                {
                    KmsKeyArn = "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                },
                IamInstanceProfile = "my--1p-dev-nodepool",
                InstanceType = "t3.medium",
                Labels = 
                {
                    { "label-one", "value-one" },
                },
                RootVolume = new Gcp.Container.Inputs.AwsNodePoolConfigRootVolumeArgs
                {
                    Iops = 3000,
                    KmsKeyArn = "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                    SizeGib = 10,
                    VolumeType = "GP3",
                },
                SecurityGroupIds = new[]
                {
                    "sg-00000000000000000",
                },
                ProxyConfig = new Gcp.Container.Inputs.AwsNodePoolConfigProxyConfigArgs
                {
                    SecretArn = "arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF",
                    SecretVersion = "12345678-ABCD-EFGH-IJKL-987654321098",
                },
                SshConfig = new Gcp.Container.Inputs.AwsNodePoolConfigSshConfigArgs
                {
                    Ec2KeyPair = "my--1p-dev-ssh",
                },
                Tags = 
                {
                    { "tag-one", "value-one" },
                },
                Taints = new[]
                {
                    new Gcp.Container.Inputs.AwsNodePoolConfigTaintArgs
                    {
                        Effect = "PREFER_NO_SCHEDULE",
                        Key = "taint-key",
                        Value = "taint-value",
                    },
                },
            },
            Location = "us-west1",
            MaxPodsConstraint = new Gcp.Container.Inputs.AwsNodePoolMaxPodsConstraintArgs
            {
                MaxPodsPerNode = 110,
            },
            Name = "node-pool-name",
            SubnetId = "subnet-00000000000000000",
            Version = versions.Apply(getAwsVersionsResult => getAwsVersionsResult.ValidVersions[0]),
            Annotations = 
            {
                { "label-one", "value-one" },
            },
            Management = new Gcp.Container.Inputs.AwsNodePoolManagementArgs
            {
                AutoRepair = true,
            },
            Project = "my-project-name",
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.gcp.container.ContainerFunctions;
    import com.pulumi.gcp.container.inputs.GetAwsVersionsArgs;
    import com.pulumi.gcp.container.AwsCluster;
    import com.pulumi.gcp.container.AwsClusterArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterAuthorizationArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterControlPlaneArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterControlPlaneAwsServicesAuthenticationArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterControlPlaneConfigEncryptionArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterControlPlaneDatabaseEncryptionArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterControlPlaneMainVolumeArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterControlPlaneProxyConfigArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterControlPlaneRootVolumeArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterControlPlaneSshConfigArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterFleetArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterNetworkingArgs;
    import com.pulumi.gcp.container.AwsNodePool;
    import com.pulumi.gcp.container.AwsNodePoolArgs;
    import com.pulumi.gcp.container.inputs.AwsNodePoolAutoscalingArgs;
    import com.pulumi.gcp.container.inputs.AwsNodePoolConfigArgs;
    import com.pulumi.gcp.container.inputs.AwsNodePoolConfigConfigEncryptionArgs;
    import com.pulumi.gcp.container.inputs.AwsNodePoolConfigRootVolumeArgs;
    import com.pulumi.gcp.container.inputs.AwsNodePoolConfigProxyConfigArgs;
    import com.pulumi.gcp.container.inputs.AwsNodePoolConfigSshConfigArgs;
    import com.pulumi.gcp.container.inputs.AwsNodePoolMaxPodsConstraintArgs;
    import com.pulumi.gcp.container.inputs.AwsNodePoolManagementArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            final var versions = ContainerFunctions.getAwsVersions(GetAwsVersionsArgs.builder()
                .project("my-project-name")
                .location("us-west1")
                .build());
    
            var primary = new AwsCluster("primary", AwsClusterArgs.builder()
                .authorization(AwsClusterAuthorizationArgs.builder()
                    .adminUsers(AwsClusterAuthorizationAdminUserArgs.builder()
                        .username("my@service-account.com")
                        .build())
                    .build())
                .awsRegion("my-aws-region")
                .controlPlane(AwsClusterControlPlaneArgs.builder()
                    .awsServicesAuthentication(AwsClusterControlPlaneAwsServicesAuthenticationArgs.builder()
                        .roleArn("arn:aws:iam::012345678910:role/my--1p-dev-oneplatform")
                        .roleSessionName("my--1p-dev-session")
                        .build())
                    .configEncryption(AwsClusterControlPlaneConfigEncryptionArgs.builder()
                        .kmsKeyArn("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111")
                        .build())
                    .databaseEncryption(AwsClusterControlPlaneDatabaseEncryptionArgs.builder()
                        .kmsKeyArn("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111")
                        .build())
                    .iamInstanceProfile("my--1p-dev-controlplane")
                    .subnetIds("subnet-00000000000000000")
                    .version(versions.applyValue(getAwsVersionsResult -> getAwsVersionsResult.validVersions()[0]))
                    .instanceType("t3.medium")
                    .mainVolume(AwsClusterControlPlaneMainVolumeArgs.builder()
                        .iops(3000)
                        .kmsKeyArn("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111")
                        .sizeGib(10)
                        .volumeType("GP3")
                        .build())
                    .proxyConfig(AwsClusterControlPlaneProxyConfigArgs.builder()
                        .secretArn("arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF")
                        .secretVersion("12345678-ABCD-EFGH-IJKL-987654321098")
                        .build())
                    .rootVolume(AwsClusterControlPlaneRootVolumeArgs.builder()
                        .iops(3000)
                        .kmsKeyArn("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111")
                        .sizeGib(10)
                        .volumeType("GP3")
                        .build())
                    .securityGroupIds("sg-00000000000000000")
                    .sshConfig(AwsClusterControlPlaneSshConfigArgs.builder()
                        .ec2KeyPair("my--1p-dev-ssh")
                        .build())
                    .tags(Map.of("owner", "my@service-account.com"))
                    .build())
                .fleet(AwsClusterFleetArgs.builder()
                    .project("my-project-number")
                    .build())
                .location("us-west1")
                .name("name")
                .networking(AwsClusterNetworkingArgs.builder()
                    .podAddressCidrBlocks("10.2.0.0/16")
                    .serviceAddressCidrBlocks("10.1.0.0/16")
                    .vpcId("vpc-00000000000000000")
                    .build())
                .annotations(Map.of("label-one", "value-one"))
                .description("A sample aws cluster")
                .project("my-project-name")
                .build());
    
            var primaryAwsNodePool = new AwsNodePool("primaryAwsNodePool", AwsNodePoolArgs.builder()
                .autoscaling(AwsNodePoolAutoscalingArgs.builder()
                    .maxNodeCount(5)
                    .minNodeCount(1)
                    .build())
                .cluster(primary.name())
                .config(AwsNodePoolConfigArgs.builder()
                    .configEncryption(AwsNodePoolConfigConfigEncryptionArgs.builder()
                        .kmsKeyArn("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111")
                        .build())
                    .iamInstanceProfile("my--1p-dev-nodepool")
                    .instanceType("t3.medium")
                    .labels(Map.of("label-one", "value-one"))
                    .rootVolume(AwsNodePoolConfigRootVolumeArgs.builder()
                        .iops(3000)
                        .kmsKeyArn("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111")
                        .sizeGib(10)
                        .volumeType("GP3")
                        .build())
                    .securityGroupIds("sg-00000000000000000")
                    .proxyConfig(AwsNodePoolConfigProxyConfigArgs.builder()
                        .secretArn("arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF")
                        .secretVersion("12345678-ABCD-EFGH-IJKL-987654321098")
                        .build())
                    .sshConfig(AwsNodePoolConfigSshConfigArgs.builder()
                        .ec2KeyPair("my--1p-dev-ssh")
                        .build())
                    .tags(Map.of("tag-one", "value-one"))
                    .taints(AwsNodePoolConfigTaintArgs.builder()
                        .effect("PREFER_NO_SCHEDULE")
                        .key("taint-key")
                        .value("taint-value")
                        .build())
                    .build())
                .location("us-west1")
                .maxPodsConstraint(AwsNodePoolMaxPodsConstraintArgs.builder()
                    .maxPodsPerNode(110)
                    .build())
                .name("node-pool-name")
                .subnetId("subnet-00000000000000000")
                .version(versions.applyValue(getAwsVersionsResult -> getAwsVersionsResult.validVersions()[0]))
                .annotations(Map.of("label-one", "value-one"))
                .management(AwsNodePoolManagementArgs.builder()
                    .autoRepair(true)
                    .build())
                .project("my-project-name")
                .build());
    
        }
    }
    
    resources:
      primary:
        type: gcp:container:AwsCluster
        properties:
          authorization:
            adminUsers:
              - username: my@service-account.com
          awsRegion: my-aws-region
          controlPlane:
            awsServicesAuthentication:
              roleArn: arn:aws:iam::012345678910:role/my--1p-dev-oneplatform
              roleSessionName: my--1p-dev-session
            configEncryption:
              kmsKeyArn: arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111
            databaseEncryption:
              kmsKeyArn: arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111
            iamInstanceProfile: my--1p-dev-controlplane
            subnetIds:
              - subnet-00000000000000000
            version: ${versions.validVersions[0]}
            instanceType: t3.medium
            mainVolume:
              iops: 3000
              kmsKeyArn: arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111
              sizeGib: 10
              volumeType: GP3
            proxyConfig:
              secretArn: arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF
              secretVersion: 12345678-ABCD-EFGH-IJKL-987654321098
            rootVolume:
              iops: 3000
              kmsKeyArn: arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111
              sizeGib: 10
              volumeType: GP3
            securityGroupIds:
              - sg-00000000000000000
            sshConfig:
              ec2KeyPair: my--1p-dev-ssh
            tags:
              owner: my@service-account.com
          fleet:
            project: my-project-number
          location: us-west1
          name: name
          networking:
            podAddressCidrBlocks:
              - 10.2.0.0/16
            serviceAddressCidrBlocks:
              - 10.1.0.0/16
            vpcId: vpc-00000000000000000
          annotations:
            label-one: value-one
          description: A sample aws cluster
          project: my-project-name
      primaryAwsNodePool:
        type: gcp:container:AwsNodePool
        name: primary
        properties:
          autoscaling:
            maxNodeCount: 5
            minNodeCount: 1
          cluster: ${primary.name}
          config:
            configEncryption:
              kmsKeyArn: arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111
            iamInstanceProfile: my--1p-dev-nodepool
            instanceType: t3.medium
            labels:
              label-one: value-one
            rootVolume:
              iops: 3000
              kmsKeyArn: arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111
              sizeGib: 10
              volumeType: GP3
            securityGroupIds:
              - sg-00000000000000000
            proxyConfig:
              secretArn: arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF
              secretVersion: 12345678-ABCD-EFGH-IJKL-987654321098
            sshConfig:
              ec2KeyPair: my--1p-dev-ssh
            tags:
              tag-one: value-one
            taints:
              - effect: PREFER_NO_SCHEDULE
                key: taint-key
                value: taint-value
          location: us-west1
          maxPodsConstraint:
            maxPodsPerNode: 110
          name: node-pool-name
          subnetId: subnet-00000000000000000
          version: ${versions.validVersions[0]}
          annotations:
            label-one: value-one
          management:
            autoRepair: true
          project: my-project-name
    variables:
      versions:
        fn::invoke:
          Function: gcp:container:getAwsVersions
          Arguments:
            project: my-project-name
            location: us-west1
    

    Basic_enum_aws_cluster

    A basic example of a containeraws node pool with lowercase enums

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    
    const versions = gcp.container.getAwsVersions({
        project: "my-project-name",
        location: "us-west1",
    });
    const primary = new gcp.container.AwsCluster("primary", {
        authorization: {
            adminUsers: [{
                username: "my@service-account.com",
            }],
        },
        awsRegion: "my-aws-region",
        controlPlane: {
            awsServicesAuthentication: {
                roleArn: "arn:aws:iam::012345678910:role/my--1p-dev-oneplatform",
                roleSessionName: "my--1p-dev-session",
            },
            configEncryption: {
                kmsKeyArn: "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
            },
            databaseEncryption: {
                kmsKeyArn: "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
            },
            iamInstanceProfile: "my--1p-dev-controlplane",
            subnetIds: ["subnet-00000000000000000"],
            version: versions.then(versions => versions.validVersions?.[0]),
            instanceType: "t3.medium",
            mainVolume: {
                iops: 3000,
                kmsKeyArn: "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                sizeGib: 10,
                volumeType: "GP3",
            },
            proxyConfig: {
                secretArn: "arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF",
                secretVersion: "12345678-ABCD-EFGH-IJKL-987654321098",
            },
            rootVolume: {
                iops: 3000,
                kmsKeyArn: "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                sizeGib: 10,
                volumeType: "GP3",
            },
            securityGroupIds: ["sg-00000000000000000"],
            sshConfig: {
                ec2KeyPair: "my--1p-dev-ssh",
            },
            tags: {
                owner: "my@service-account.com",
            },
        },
        fleet: {
            project: "my-project-number",
        },
        location: "us-west1",
        name: "name",
        networking: {
            podAddressCidrBlocks: ["10.2.0.0/16"],
            serviceAddressCidrBlocks: ["10.1.0.0/16"],
            vpcId: "vpc-00000000000000000",
        },
        annotations: {
            "label-one": "value-one",
        },
        description: "A sample aws cluster",
        project: "my-project-name",
    });
    const primaryAwsNodePool = new gcp.container.AwsNodePool("primary", {
        autoscaling: {
            maxNodeCount: 5,
            minNodeCount: 1,
        },
        cluster: primary.name,
        config: {
            configEncryption: {
                kmsKeyArn: "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
            },
            iamInstanceProfile: "my--1p-dev-nodepool",
            instanceType: "t3.medium",
            labels: {
                "label-one": "value-one",
            },
            rootVolume: {
                iops: 3000,
                kmsKeyArn: "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                sizeGib: 10,
                volumeType: "gp3",
            },
            securityGroupIds: ["sg-00000000000000000"],
            proxyConfig: {
                secretArn: "arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF",
                secretVersion: "12345678-ABCD-EFGH-IJKL-987654321098",
            },
            sshConfig: {
                ec2KeyPair: "my--1p-dev-ssh",
            },
            tags: {
                "tag-one": "value-one",
            },
            taints: [{
                effect: "prefer_no_schedule",
                key: "taint-key",
                value: "taint-value",
            }],
        },
        location: "us-west1",
        maxPodsConstraint: {
            maxPodsPerNode: 110,
        },
        name: "node-pool-name",
        subnetId: "subnet-00000000000000000",
        version: versions.then(versions => versions.validVersions?.[0]),
        annotations: {
            "label-one": "value-one",
        },
        project: "my-project-name",
    });
    
    import pulumi
    import pulumi_gcp as gcp
    
    versions = gcp.container.get_aws_versions(project="my-project-name",
        location="us-west1")
    primary = gcp.container.AwsCluster("primary",
        authorization=gcp.container.AwsClusterAuthorizationArgs(
            admin_users=[gcp.container.AwsClusterAuthorizationAdminUserArgs(
                username="my@service-account.com",
            )],
        ),
        aws_region="my-aws-region",
        control_plane=gcp.container.AwsClusterControlPlaneArgs(
            aws_services_authentication=gcp.container.AwsClusterControlPlaneAwsServicesAuthenticationArgs(
                role_arn="arn:aws:iam::012345678910:role/my--1p-dev-oneplatform",
                role_session_name="my--1p-dev-session",
            ),
            config_encryption=gcp.container.AwsClusterControlPlaneConfigEncryptionArgs(
                kms_key_arn="arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
            ),
            database_encryption=gcp.container.AwsClusterControlPlaneDatabaseEncryptionArgs(
                kms_key_arn="arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
            ),
            iam_instance_profile="my--1p-dev-controlplane",
            subnet_ids=["subnet-00000000000000000"],
            version=versions.valid_versions[0],
            instance_type="t3.medium",
            main_volume=gcp.container.AwsClusterControlPlaneMainVolumeArgs(
                iops=3000,
                kms_key_arn="arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                size_gib=10,
                volume_type="GP3",
            ),
            proxy_config=gcp.container.AwsClusterControlPlaneProxyConfigArgs(
                secret_arn="arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF",
                secret_version="12345678-ABCD-EFGH-IJKL-987654321098",
            ),
            root_volume=gcp.container.AwsClusterControlPlaneRootVolumeArgs(
                iops=3000,
                kms_key_arn="arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                size_gib=10,
                volume_type="GP3",
            ),
            security_group_ids=["sg-00000000000000000"],
            ssh_config=gcp.container.AwsClusterControlPlaneSshConfigArgs(
                ec2_key_pair="my--1p-dev-ssh",
            ),
            tags={
                "owner": "my@service-account.com",
            },
        ),
        fleet=gcp.container.AwsClusterFleetArgs(
            project="my-project-number",
        ),
        location="us-west1",
        name="name",
        networking=gcp.container.AwsClusterNetworkingArgs(
            pod_address_cidr_blocks=["10.2.0.0/16"],
            service_address_cidr_blocks=["10.1.0.0/16"],
            vpc_id="vpc-00000000000000000",
        ),
        annotations={
            "label-one": "value-one",
        },
        description="A sample aws cluster",
        project="my-project-name")
    primary_aws_node_pool = gcp.container.AwsNodePool("primary",
        autoscaling=gcp.container.AwsNodePoolAutoscalingArgs(
            max_node_count=5,
            min_node_count=1,
        ),
        cluster=primary.name,
        config=gcp.container.AwsNodePoolConfigArgs(
            config_encryption=gcp.container.AwsNodePoolConfigConfigEncryptionArgs(
                kms_key_arn="arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
            ),
            iam_instance_profile="my--1p-dev-nodepool",
            instance_type="t3.medium",
            labels={
                "label-one": "value-one",
            },
            root_volume=gcp.container.AwsNodePoolConfigRootVolumeArgs(
                iops=3000,
                kms_key_arn="arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                size_gib=10,
                volume_type="gp3",
            ),
            security_group_ids=["sg-00000000000000000"],
            proxy_config=gcp.container.AwsNodePoolConfigProxyConfigArgs(
                secret_arn="arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF",
                secret_version="12345678-ABCD-EFGH-IJKL-987654321098",
            ),
            ssh_config=gcp.container.AwsNodePoolConfigSshConfigArgs(
                ec2_key_pair="my--1p-dev-ssh",
            ),
            tags={
                "tag-one": "value-one",
            },
            taints=[gcp.container.AwsNodePoolConfigTaintArgs(
                effect="prefer_no_schedule",
                key="taint-key",
                value="taint-value",
            )],
        ),
        location="us-west1",
        max_pods_constraint=gcp.container.AwsNodePoolMaxPodsConstraintArgs(
            max_pods_per_node=110,
        ),
        name="node-pool-name",
        subnet_id="subnet-00000000000000000",
        version=versions.valid_versions[0],
        annotations={
            "label-one": "value-one",
        },
        project="my-project-name")
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/container"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		versions, err := container.GetAwsVersions(ctx, &container.GetAwsVersionsArgs{
    			Project:  pulumi.StringRef("my-project-name"),
    			Location: pulumi.StringRef("us-west1"),
    		}, nil)
    		if err != nil {
    			return err
    		}
    		primary, err := container.NewAwsCluster(ctx, "primary", &container.AwsClusterArgs{
    			Authorization: &container.AwsClusterAuthorizationArgs{
    				AdminUsers: container.AwsClusterAuthorizationAdminUserArray{
    					&container.AwsClusterAuthorizationAdminUserArgs{
    						Username: pulumi.String("my@service-account.com"),
    					},
    				},
    			},
    			AwsRegion: pulumi.String("my-aws-region"),
    			ControlPlane: &container.AwsClusterControlPlaneArgs{
    				AwsServicesAuthentication: &container.AwsClusterControlPlaneAwsServicesAuthenticationArgs{
    					RoleArn:         pulumi.String("arn:aws:iam::012345678910:role/my--1p-dev-oneplatform"),
    					RoleSessionName: pulumi.String("my--1p-dev-session"),
    				},
    				ConfigEncryption: &container.AwsClusterControlPlaneConfigEncryptionArgs{
    					KmsKeyArn: pulumi.String("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111"),
    				},
    				DatabaseEncryption: &container.AwsClusterControlPlaneDatabaseEncryptionArgs{
    					KmsKeyArn: pulumi.String("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111"),
    				},
    				IamInstanceProfile: pulumi.String("my--1p-dev-controlplane"),
    				SubnetIds: pulumi.StringArray{
    					pulumi.String("subnet-00000000000000000"),
    				},
    				Version:      pulumi.String(versions.ValidVersions[0]),
    				InstanceType: pulumi.String("t3.medium"),
    				MainVolume: &container.AwsClusterControlPlaneMainVolumeArgs{
    					Iops:       pulumi.Int(3000),
    					KmsKeyArn:  pulumi.String("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111"),
    					SizeGib:    pulumi.Int(10),
    					VolumeType: pulumi.String("GP3"),
    				},
    				ProxyConfig: &container.AwsClusterControlPlaneProxyConfigArgs{
    					SecretArn:     pulumi.String("arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF"),
    					SecretVersion: pulumi.String("12345678-ABCD-EFGH-IJKL-987654321098"),
    				},
    				RootVolume: &container.AwsClusterControlPlaneRootVolumeArgs{
    					Iops:       pulumi.Int(3000),
    					KmsKeyArn:  pulumi.String("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111"),
    					SizeGib:    pulumi.Int(10),
    					VolumeType: pulumi.String("GP3"),
    				},
    				SecurityGroupIds: pulumi.StringArray{
    					pulumi.String("sg-00000000000000000"),
    				},
    				SshConfig: &container.AwsClusterControlPlaneSshConfigArgs{
    					Ec2KeyPair: pulumi.String("my--1p-dev-ssh"),
    				},
    				Tags: pulumi.StringMap{
    					"owner": pulumi.String("my@service-account.com"),
    				},
    			},
    			Fleet: &container.AwsClusterFleetArgs{
    				Project: pulumi.String("my-project-number"),
    			},
    			Location: pulumi.String("us-west1"),
    			Name:     pulumi.String("name"),
    			Networking: &container.AwsClusterNetworkingArgs{
    				PodAddressCidrBlocks: pulumi.StringArray{
    					pulumi.String("10.2.0.0/16"),
    				},
    				ServiceAddressCidrBlocks: pulumi.StringArray{
    					pulumi.String("10.1.0.0/16"),
    				},
    				VpcId: pulumi.String("vpc-00000000000000000"),
    			},
    			Annotations: pulumi.StringMap{
    				"label-one": pulumi.String("value-one"),
    			},
    			Description: pulumi.String("A sample aws cluster"),
    			Project:     pulumi.String("my-project-name"),
    		})
    		if err != nil {
    			return err
    		}
    		_, err = container.NewAwsNodePool(ctx, "primary", &container.AwsNodePoolArgs{
    			Autoscaling: &container.AwsNodePoolAutoscalingArgs{
    				MaxNodeCount: pulumi.Int(5),
    				MinNodeCount: pulumi.Int(1),
    			},
    			Cluster: primary.Name,
    			Config: &container.AwsNodePoolConfigArgs{
    				ConfigEncryption: &container.AwsNodePoolConfigConfigEncryptionArgs{
    					KmsKeyArn: pulumi.String("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111"),
    				},
    				IamInstanceProfile: pulumi.String("my--1p-dev-nodepool"),
    				InstanceType:       pulumi.String("t3.medium"),
    				Labels: pulumi.StringMap{
    					"label-one": pulumi.String("value-one"),
    				},
    				RootVolume: &container.AwsNodePoolConfigRootVolumeArgs{
    					Iops:       pulumi.Int(3000),
    					KmsKeyArn:  pulumi.String("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111"),
    					SizeGib:    pulumi.Int(10),
    					VolumeType: pulumi.String("gp3"),
    				},
    				SecurityGroupIds: pulumi.StringArray{
    					pulumi.String("sg-00000000000000000"),
    				},
    				ProxyConfig: &container.AwsNodePoolConfigProxyConfigArgs{
    					SecretArn:     pulumi.String("arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF"),
    					SecretVersion: pulumi.String("12345678-ABCD-EFGH-IJKL-987654321098"),
    				},
    				SshConfig: &container.AwsNodePoolConfigSshConfigArgs{
    					Ec2KeyPair: pulumi.String("my--1p-dev-ssh"),
    				},
    				Tags: pulumi.StringMap{
    					"tag-one": pulumi.String("value-one"),
    				},
    				Taints: container.AwsNodePoolConfigTaintArray{
    					&container.AwsNodePoolConfigTaintArgs{
    						Effect: pulumi.String("prefer_no_schedule"),
    						Key:    pulumi.String("taint-key"),
    						Value:  pulumi.String("taint-value"),
    					},
    				},
    			},
    			Location: pulumi.String("us-west1"),
    			MaxPodsConstraint: &container.AwsNodePoolMaxPodsConstraintArgs{
    				MaxPodsPerNode: pulumi.Int(110),
    			},
    			Name:     pulumi.String("node-pool-name"),
    			SubnetId: pulumi.String("subnet-00000000000000000"),
    			Version:  pulumi.String(versions.ValidVersions[0]),
    			Annotations: pulumi.StringMap{
    				"label-one": pulumi.String("value-one"),
    			},
    			Project: pulumi.String("my-project-name"),
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Gcp = Pulumi.Gcp;
    
    return await Deployment.RunAsync(() => 
    {
        var versions = Gcp.Container.GetAwsVersions.Invoke(new()
        {
            Project = "my-project-name",
            Location = "us-west1",
        });
    
        var primary = new Gcp.Container.AwsCluster("primary", new()
        {
            Authorization = new Gcp.Container.Inputs.AwsClusterAuthorizationArgs
            {
                AdminUsers = new[]
                {
                    new Gcp.Container.Inputs.AwsClusterAuthorizationAdminUserArgs
                    {
                        Username = "my@service-account.com",
                    },
                },
            },
            AwsRegion = "my-aws-region",
            ControlPlane = new Gcp.Container.Inputs.AwsClusterControlPlaneArgs
            {
                AwsServicesAuthentication = new Gcp.Container.Inputs.AwsClusterControlPlaneAwsServicesAuthenticationArgs
                {
                    RoleArn = "arn:aws:iam::012345678910:role/my--1p-dev-oneplatform",
                    RoleSessionName = "my--1p-dev-session",
                },
                ConfigEncryption = new Gcp.Container.Inputs.AwsClusterControlPlaneConfigEncryptionArgs
                {
                    KmsKeyArn = "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                },
                DatabaseEncryption = new Gcp.Container.Inputs.AwsClusterControlPlaneDatabaseEncryptionArgs
                {
                    KmsKeyArn = "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                },
                IamInstanceProfile = "my--1p-dev-controlplane",
                SubnetIds = new[]
                {
                    "subnet-00000000000000000",
                },
                Version = versions.Apply(getAwsVersionsResult => getAwsVersionsResult.ValidVersions[0]),
                InstanceType = "t3.medium",
                MainVolume = new Gcp.Container.Inputs.AwsClusterControlPlaneMainVolumeArgs
                {
                    Iops = 3000,
                    KmsKeyArn = "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                    SizeGib = 10,
                    VolumeType = "GP3",
                },
                ProxyConfig = new Gcp.Container.Inputs.AwsClusterControlPlaneProxyConfigArgs
                {
                    SecretArn = "arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF",
                    SecretVersion = "12345678-ABCD-EFGH-IJKL-987654321098",
                },
                RootVolume = new Gcp.Container.Inputs.AwsClusterControlPlaneRootVolumeArgs
                {
                    Iops = 3000,
                    KmsKeyArn = "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                    SizeGib = 10,
                    VolumeType = "GP3",
                },
                SecurityGroupIds = new[]
                {
                    "sg-00000000000000000",
                },
                SshConfig = new Gcp.Container.Inputs.AwsClusterControlPlaneSshConfigArgs
                {
                    Ec2KeyPair = "my--1p-dev-ssh",
                },
                Tags = 
                {
                    { "owner", "my@service-account.com" },
                },
            },
            Fleet = new Gcp.Container.Inputs.AwsClusterFleetArgs
            {
                Project = "my-project-number",
            },
            Location = "us-west1",
            Name = "name",
            Networking = new Gcp.Container.Inputs.AwsClusterNetworkingArgs
            {
                PodAddressCidrBlocks = new[]
                {
                    "10.2.0.0/16",
                },
                ServiceAddressCidrBlocks = new[]
                {
                    "10.1.0.0/16",
                },
                VpcId = "vpc-00000000000000000",
            },
            Annotations = 
            {
                { "label-one", "value-one" },
            },
            Description = "A sample aws cluster",
            Project = "my-project-name",
        });
    
        var primaryAwsNodePool = new Gcp.Container.AwsNodePool("primary", new()
        {
            Autoscaling = new Gcp.Container.Inputs.AwsNodePoolAutoscalingArgs
            {
                MaxNodeCount = 5,
                MinNodeCount = 1,
            },
            Cluster = primary.Name,
            Config = new Gcp.Container.Inputs.AwsNodePoolConfigArgs
            {
                ConfigEncryption = new Gcp.Container.Inputs.AwsNodePoolConfigConfigEncryptionArgs
                {
                    KmsKeyArn = "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                },
                IamInstanceProfile = "my--1p-dev-nodepool",
                InstanceType = "t3.medium",
                Labels = 
                {
                    { "label-one", "value-one" },
                },
                RootVolume = new Gcp.Container.Inputs.AwsNodePoolConfigRootVolumeArgs
                {
                    Iops = 3000,
                    KmsKeyArn = "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                    SizeGib = 10,
                    VolumeType = "gp3",
                },
                SecurityGroupIds = new[]
                {
                    "sg-00000000000000000",
                },
                ProxyConfig = new Gcp.Container.Inputs.AwsNodePoolConfigProxyConfigArgs
                {
                    SecretArn = "arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF",
                    SecretVersion = "12345678-ABCD-EFGH-IJKL-987654321098",
                },
                SshConfig = new Gcp.Container.Inputs.AwsNodePoolConfigSshConfigArgs
                {
                    Ec2KeyPair = "my--1p-dev-ssh",
                },
                Tags = 
                {
                    { "tag-one", "value-one" },
                },
                Taints = new[]
                {
                    new Gcp.Container.Inputs.AwsNodePoolConfigTaintArgs
                    {
                        Effect = "prefer_no_schedule",
                        Key = "taint-key",
                        Value = "taint-value",
                    },
                },
            },
            Location = "us-west1",
            MaxPodsConstraint = new Gcp.Container.Inputs.AwsNodePoolMaxPodsConstraintArgs
            {
                MaxPodsPerNode = 110,
            },
            Name = "node-pool-name",
            SubnetId = "subnet-00000000000000000",
            Version = versions.Apply(getAwsVersionsResult => getAwsVersionsResult.ValidVersions[0]),
            Annotations = 
            {
                { "label-one", "value-one" },
            },
            Project = "my-project-name",
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.gcp.container.ContainerFunctions;
    import com.pulumi.gcp.container.inputs.GetAwsVersionsArgs;
    import com.pulumi.gcp.container.AwsCluster;
    import com.pulumi.gcp.container.AwsClusterArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterAuthorizationArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterControlPlaneArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterControlPlaneAwsServicesAuthenticationArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterControlPlaneConfigEncryptionArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterControlPlaneDatabaseEncryptionArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterControlPlaneMainVolumeArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterControlPlaneProxyConfigArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterControlPlaneRootVolumeArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterControlPlaneSshConfigArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterFleetArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterNetworkingArgs;
    import com.pulumi.gcp.container.AwsNodePool;
    import com.pulumi.gcp.container.AwsNodePoolArgs;
    import com.pulumi.gcp.container.inputs.AwsNodePoolAutoscalingArgs;
    import com.pulumi.gcp.container.inputs.AwsNodePoolConfigArgs;
    import com.pulumi.gcp.container.inputs.AwsNodePoolConfigConfigEncryptionArgs;
    import com.pulumi.gcp.container.inputs.AwsNodePoolConfigRootVolumeArgs;
    import com.pulumi.gcp.container.inputs.AwsNodePoolConfigProxyConfigArgs;
    import com.pulumi.gcp.container.inputs.AwsNodePoolConfigSshConfigArgs;
    import com.pulumi.gcp.container.inputs.AwsNodePoolMaxPodsConstraintArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            final var versions = ContainerFunctions.getAwsVersions(GetAwsVersionsArgs.builder()
                .project("my-project-name")
                .location("us-west1")
                .build());
    
            var primary = new AwsCluster("primary", AwsClusterArgs.builder()
                .authorization(AwsClusterAuthorizationArgs.builder()
                    .adminUsers(AwsClusterAuthorizationAdminUserArgs.builder()
                        .username("my@service-account.com")
                        .build())
                    .build())
                .awsRegion("my-aws-region")
                .controlPlane(AwsClusterControlPlaneArgs.builder()
                    .awsServicesAuthentication(AwsClusterControlPlaneAwsServicesAuthenticationArgs.builder()
                        .roleArn("arn:aws:iam::012345678910:role/my--1p-dev-oneplatform")
                        .roleSessionName("my--1p-dev-session")
                        .build())
                    .configEncryption(AwsClusterControlPlaneConfigEncryptionArgs.builder()
                        .kmsKeyArn("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111")
                        .build())
                    .databaseEncryption(AwsClusterControlPlaneDatabaseEncryptionArgs.builder()
                        .kmsKeyArn("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111")
                        .build())
                    .iamInstanceProfile("my--1p-dev-controlplane")
                    .subnetIds("subnet-00000000000000000")
                    .version(versions.applyValue(getAwsVersionsResult -> getAwsVersionsResult.validVersions()[0]))
                    .instanceType("t3.medium")
                    .mainVolume(AwsClusterControlPlaneMainVolumeArgs.builder()
                        .iops(3000)
                        .kmsKeyArn("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111")
                        .sizeGib(10)
                        .volumeType("GP3")
                        .build())
                    .proxyConfig(AwsClusterControlPlaneProxyConfigArgs.builder()
                        .secretArn("arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF")
                        .secretVersion("12345678-ABCD-EFGH-IJKL-987654321098")
                        .build())
                    .rootVolume(AwsClusterControlPlaneRootVolumeArgs.builder()
                        .iops(3000)
                        .kmsKeyArn("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111")
                        .sizeGib(10)
                        .volumeType("GP3")
                        .build())
                    .securityGroupIds("sg-00000000000000000")
                    .sshConfig(AwsClusterControlPlaneSshConfigArgs.builder()
                        .ec2KeyPair("my--1p-dev-ssh")
                        .build())
                    .tags(Map.of("owner", "my@service-account.com"))
                    .build())
                .fleet(AwsClusterFleetArgs.builder()
                    .project("my-project-number")
                    .build())
                .location("us-west1")
                .name("name")
                .networking(AwsClusterNetworkingArgs.builder()
                    .podAddressCidrBlocks("10.2.0.0/16")
                    .serviceAddressCidrBlocks("10.1.0.0/16")
                    .vpcId("vpc-00000000000000000")
                    .build())
                .annotations(Map.of("label-one", "value-one"))
                .description("A sample aws cluster")
                .project("my-project-name")
                .build());
    
            var primaryAwsNodePool = new AwsNodePool("primaryAwsNodePool", AwsNodePoolArgs.builder()
                .autoscaling(AwsNodePoolAutoscalingArgs.builder()
                    .maxNodeCount(5)
                    .minNodeCount(1)
                    .build())
                .cluster(primary.name())
                .config(AwsNodePoolConfigArgs.builder()
                    .configEncryption(AwsNodePoolConfigConfigEncryptionArgs.builder()
                        .kmsKeyArn("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111")
                        .build())
                    .iamInstanceProfile("my--1p-dev-nodepool")
                    .instanceType("t3.medium")
                    .labels(Map.of("label-one", "value-one"))
                    .rootVolume(AwsNodePoolConfigRootVolumeArgs.builder()
                        .iops(3000)
                        .kmsKeyArn("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111")
                        .sizeGib(10)
                        .volumeType("gp3")
                        .build())
                    .securityGroupIds("sg-00000000000000000")
                    .proxyConfig(AwsNodePoolConfigProxyConfigArgs.builder()
                        .secretArn("arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF")
                        .secretVersion("12345678-ABCD-EFGH-IJKL-987654321098")
                        .build())
                    .sshConfig(AwsNodePoolConfigSshConfigArgs.builder()
                        .ec2KeyPair("my--1p-dev-ssh")
                        .build())
                    .tags(Map.of("tag-one", "value-one"))
                    .taints(AwsNodePoolConfigTaintArgs.builder()
                        .effect("prefer_no_schedule")
                        .key("taint-key")
                        .value("taint-value")
                        .build())
                    .build())
                .location("us-west1")
                .maxPodsConstraint(AwsNodePoolMaxPodsConstraintArgs.builder()
                    .maxPodsPerNode(110)
                    .build())
                .name("node-pool-name")
                .subnetId("subnet-00000000000000000")
                .version(versions.applyValue(getAwsVersionsResult -> getAwsVersionsResult.validVersions()[0]))
                .annotations(Map.of("label-one", "value-one"))
                .project("my-project-name")
                .build());
    
        }
    }
    
    resources:
      primary:
        type: gcp:container:AwsCluster
        properties:
          authorization:
            adminUsers:
              - username: my@service-account.com
          awsRegion: my-aws-region
          controlPlane:
            awsServicesAuthentication:
              roleArn: arn:aws:iam::012345678910:role/my--1p-dev-oneplatform
              roleSessionName: my--1p-dev-session
            configEncryption:
              kmsKeyArn: arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111
            databaseEncryption:
              kmsKeyArn: arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111
            iamInstanceProfile: my--1p-dev-controlplane
            subnetIds:
              - subnet-00000000000000000
            version: ${versions.validVersions[0]}
            instanceType: t3.medium
            mainVolume:
              iops: 3000
              kmsKeyArn: arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111
              sizeGib: 10
              volumeType: GP3
            proxyConfig:
              secretArn: arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF
              secretVersion: 12345678-ABCD-EFGH-IJKL-987654321098
            rootVolume:
              iops: 3000
              kmsKeyArn: arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111
              sizeGib: 10
              volumeType: GP3
            securityGroupIds:
              - sg-00000000000000000
            sshConfig:
              ec2KeyPair: my--1p-dev-ssh
            tags:
              owner: my@service-account.com
          fleet:
            project: my-project-number
          location: us-west1
          name: name
          networking:
            podAddressCidrBlocks:
              - 10.2.0.0/16
            serviceAddressCidrBlocks:
              - 10.1.0.0/16
            vpcId: vpc-00000000000000000
          annotations:
            label-one: value-one
          description: A sample aws cluster
          project: my-project-name
      primaryAwsNodePool:
        type: gcp:container:AwsNodePool
        name: primary
        properties:
          autoscaling:
            maxNodeCount: 5
            minNodeCount: 1
          cluster: ${primary.name}
          config:
            configEncryption:
              kmsKeyArn: arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111
            iamInstanceProfile: my--1p-dev-nodepool
            instanceType: t3.medium
            labels:
              label-one: value-one
            rootVolume:
              iops: 3000
              kmsKeyArn: arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111
              sizeGib: 10
              volumeType: gp3
            securityGroupIds:
              - sg-00000000000000000
            proxyConfig:
              secretArn: arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF
              secretVersion: 12345678-ABCD-EFGH-IJKL-987654321098
            sshConfig:
              ec2KeyPair: my--1p-dev-ssh
            tags:
              tag-one: value-one
            taints:
              - effect: prefer_no_schedule
                key: taint-key
                value: taint-value
          location: us-west1
          maxPodsConstraint:
            maxPodsPerNode: 110
          name: node-pool-name
          subnetId: subnet-00000000000000000
          version: ${versions.validVersions[0]}
          annotations:
            label-one: value-one
          project: my-project-name
    variables:
      versions:
        fn::invoke:
          Function: gcp:container:getAwsVersions
          Arguments:
            project: my-project-name
            location: us-west1
    

    Beta_basic_enum_aws_cluster

    A basic example of a containeraws node pool with lowercase enums (beta)

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    
    const versions = gcp.container.getAwsVersions({
        project: "my-project-name",
        location: "us-west1",
    });
    const primary = new gcp.container.AwsCluster("primary", {
        authorization: {
            adminUsers: [{
                username: "my@service-account.com",
            }],
        },
        awsRegion: "my-aws-region",
        controlPlane: {
            awsServicesAuthentication: {
                roleArn: "arn:aws:iam::012345678910:role/my--1p-dev-oneplatform",
                roleSessionName: "my--1p-dev-session",
            },
            configEncryption: {
                kmsKeyArn: "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
            },
            databaseEncryption: {
                kmsKeyArn: "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
            },
            iamInstanceProfile: "my--1p-dev-controlplane",
            subnetIds: ["subnet-00000000000000000"],
            version: versions.then(versions => versions.validVersions?.[0]),
            instanceType: "t3.medium",
            mainVolume: {
                iops: 3000,
                kmsKeyArn: "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                sizeGib: 10,
                volumeType: "GP3",
            },
            proxyConfig: {
                secretArn: "arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF",
                secretVersion: "12345678-ABCD-EFGH-IJKL-987654321098",
            },
            rootVolume: {
                iops: 3000,
                kmsKeyArn: "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                sizeGib: 10,
                volumeType: "GP3",
            },
            securityGroupIds: ["sg-00000000000000000"],
            sshConfig: {
                ec2KeyPair: "my--1p-dev-ssh",
            },
            tags: {
                owner: "my@service-account.com",
            },
        },
        fleet: {
            project: "my-project-number",
        },
        location: "us-west1",
        name: "name",
        networking: {
            podAddressCidrBlocks: ["10.2.0.0/16"],
            serviceAddressCidrBlocks: ["10.1.0.0/16"],
            vpcId: "vpc-00000000000000000",
        },
        annotations: {
            "label-one": "value-one",
        },
        description: "A sample aws cluster",
        project: "my-project-name",
    });
    const primaryAwsNodePool = new gcp.container.AwsNodePool("primary", {
        autoscaling: {
            maxNodeCount: 5,
            minNodeCount: 1,
        },
        cluster: primary.name,
        config: {
            configEncryption: {
                kmsKeyArn: "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
            },
            iamInstanceProfile: "my--1p-dev-nodepool",
            instanceType: "t3.medium",
            labels: {
                "label-one": "value-one",
            },
            rootVolume: {
                iops: 3000,
                kmsKeyArn: "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                sizeGib: 10,
                volumeType: "gp3",
            },
            securityGroupIds: ["sg-00000000000000000"],
            proxyConfig: {
                secretArn: "arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF",
                secretVersion: "12345678-ABCD-EFGH-IJKL-987654321098",
            },
            sshConfig: {
                ec2KeyPair: "my--1p-dev-ssh",
            },
            tags: {
                "tag-one": "value-one",
            },
            taints: [{
                effect: "prefer_no_schedule",
                key: "taint-key",
                value: "taint-value",
            }],
            instancePlacement: {
                tenancy: "dedicated",
            },
            imageType: "ubuntu",
        },
        location: "us-west1",
        maxPodsConstraint: {
            maxPodsPerNode: 110,
        },
        name: "node-pool-name",
        subnetId: "subnet-00000000000000000",
        version: versions.then(versions => versions.validVersions?.[0]),
        annotations: {
            "label-one": "value-one",
        },
        project: "my-project-name",
    });
    
    import pulumi
    import pulumi_gcp as gcp
    
    versions = gcp.container.get_aws_versions(project="my-project-name",
        location="us-west1")
    primary = gcp.container.AwsCluster("primary",
        authorization=gcp.container.AwsClusterAuthorizationArgs(
            admin_users=[gcp.container.AwsClusterAuthorizationAdminUserArgs(
                username="my@service-account.com",
            )],
        ),
        aws_region="my-aws-region",
        control_plane=gcp.container.AwsClusterControlPlaneArgs(
            aws_services_authentication=gcp.container.AwsClusterControlPlaneAwsServicesAuthenticationArgs(
                role_arn="arn:aws:iam::012345678910:role/my--1p-dev-oneplatform",
                role_session_name="my--1p-dev-session",
            ),
            config_encryption=gcp.container.AwsClusterControlPlaneConfigEncryptionArgs(
                kms_key_arn="arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
            ),
            database_encryption=gcp.container.AwsClusterControlPlaneDatabaseEncryptionArgs(
                kms_key_arn="arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
            ),
            iam_instance_profile="my--1p-dev-controlplane",
            subnet_ids=["subnet-00000000000000000"],
            version=versions.valid_versions[0],
            instance_type="t3.medium",
            main_volume=gcp.container.AwsClusterControlPlaneMainVolumeArgs(
                iops=3000,
                kms_key_arn="arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                size_gib=10,
                volume_type="GP3",
            ),
            proxy_config=gcp.container.AwsClusterControlPlaneProxyConfigArgs(
                secret_arn="arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF",
                secret_version="12345678-ABCD-EFGH-IJKL-987654321098",
            ),
            root_volume=gcp.container.AwsClusterControlPlaneRootVolumeArgs(
                iops=3000,
                kms_key_arn="arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                size_gib=10,
                volume_type="GP3",
            ),
            security_group_ids=["sg-00000000000000000"],
            ssh_config=gcp.container.AwsClusterControlPlaneSshConfigArgs(
                ec2_key_pair="my--1p-dev-ssh",
            ),
            tags={
                "owner": "my@service-account.com",
            },
        ),
        fleet=gcp.container.AwsClusterFleetArgs(
            project="my-project-number",
        ),
        location="us-west1",
        name="name",
        networking=gcp.container.AwsClusterNetworkingArgs(
            pod_address_cidr_blocks=["10.2.0.0/16"],
            service_address_cidr_blocks=["10.1.0.0/16"],
            vpc_id="vpc-00000000000000000",
        ),
        annotations={
            "label-one": "value-one",
        },
        description="A sample aws cluster",
        project="my-project-name")
    primary_aws_node_pool = gcp.container.AwsNodePool("primary",
        autoscaling=gcp.container.AwsNodePoolAutoscalingArgs(
            max_node_count=5,
            min_node_count=1,
        ),
        cluster=primary.name,
        config=gcp.container.AwsNodePoolConfigArgs(
            config_encryption=gcp.container.AwsNodePoolConfigConfigEncryptionArgs(
                kms_key_arn="arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
            ),
            iam_instance_profile="my--1p-dev-nodepool",
            instance_type="t3.medium",
            labels={
                "label-one": "value-one",
            },
            root_volume=gcp.container.AwsNodePoolConfigRootVolumeArgs(
                iops=3000,
                kms_key_arn="arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                size_gib=10,
                volume_type="gp3",
            ),
            security_group_ids=["sg-00000000000000000"],
            proxy_config=gcp.container.AwsNodePoolConfigProxyConfigArgs(
                secret_arn="arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF",
                secret_version="12345678-ABCD-EFGH-IJKL-987654321098",
            ),
            ssh_config=gcp.container.AwsNodePoolConfigSshConfigArgs(
                ec2_key_pair="my--1p-dev-ssh",
            ),
            tags={
                "tag-one": "value-one",
            },
            taints=[gcp.container.AwsNodePoolConfigTaintArgs(
                effect="prefer_no_schedule",
                key="taint-key",
                value="taint-value",
            )],
            instance_placement=gcp.container.AwsNodePoolConfigInstancePlacementArgs(
                tenancy="dedicated",
            ),
            image_type="ubuntu",
        ),
        location="us-west1",
        max_pods_constraint=gcp.container.AwsNodePoolMaxPodsConstraintArgs(
            max_pods_per_node=110,
        ),
        name="node-pool-name",
        subnet_id="subnet-00000000000000000",
        version=versions.valid_versions[0],
        annotations={
            "label-one": "value-one",
        },
        project="my-project-name")
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/container"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		versions, err := container.GetAwsVersions(ctx, &container.GetAwsVersionsArgs{
    			Project:  pulumi.StringRef("my-project-name"),
    			Location: pulumi.StringRef("us-west1"),
    		}, nil)
    		if err != nil {
    			return err
    		}
    		primary, err := container.NewAwsCluster(ctx, "primary", &container.AwsClusterArgs{
    			Authorization: &container.AwsClusterAuthorizationArgs{
    				AdminUsers: container.AwsClusterAuthorizationAdminUserArray{
    					&container.AwsClusterAuthorizationAdminUserArgs{
    						Username: pulumi.String("my@service-account.com"),
    					},
    				},
    			},
    			AwsRegion: pulumi.String("my-aws-region"),
    			ControlPlane: &container.AwsClusterControlPlaneArgs{
    				AwsServicesAuthentication: &container.AwsClusterControlPlaneAwsServicesAuthenticationArgs{
    					RoleArn:         pulumi.String("arn:aws:iam::012345678910:role/my--1p-dev-oneplatform"),
    					RoleSessionName: pulumi.String("my--1p-dev-session"),
    				},
    				ConfigEncryption: &container.AwsClusterControlPlaneConfigEncryptionArgs{
    					KmsKeyArn: pulumi.String("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111"),
    				},
    				DatabaseEncryption: &container.AwsClusterControlPlaneDatabaseEncryptionArgs{
    					KmsKeyArn: pulumi.String("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111"),
    				},
    				IamInstanceProfile: pulumi.String("my--1p-dev-controlplane"),
    				SubnetIds: pulumi.StringArray{
    					pulumi.String("subnet-00000000000000000"),
    				},
    				Version:      pulumi.String(versions.ValidVersions[0]),
    				InstanceType: pulumi.String("t3.medium"),
    				MainVolume: &container.AwsClusterControlPlaneMainVolumeArgs{
    					Iops:       pulumi.Int(3000),
    					KmsKeyArn:  pulumi.String("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111"),
    					SizeGib:    pulumi.Int(10),
    					VolumeType: pulumi.String("GP3"),
    				},
    				ProxyConfig: &container.AwsClusterControlPlaneProxyConfigArgs{
    					SecretArn:     pulumi.String("arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF"),
    					SecretVersion: pulumi.String("12345678-ABCD-EFGH-IJKL-987654321098"),
    				},
    				RootVolume: &container.AwsClusterControlPlaneRootVolumeArgs{
    					Iops:       pulumi.Int(3000),
    					KmsKeyArn:  pulumi.String("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111"),
    					SizeGib:    pulumi.Int(10),
    					VolumeType: pulumi.String("GP3"),
    				},
    				SecurityGroupIds: pulumi.StringArray{
    					pulumi.String("sg-00000000000000000"),
    				},
    				SshConfig: &container.AwsClusterControlPlaneSshConfigArgs{
    					Ec2KeyPair: pulumi.String("my--1p-dev-ssh"),
    				},
    				Tags: pulumi.StringMap{
    					"owner": pulumi.String("my@service-account.com"),
    				},
    			},
    			Fleet: &container.AwsClusterFleetArgs{
    				Project: pulumi.String("my-project-number"),
    			},
    			Location: pulumi.String("us-west1"),
    			Name:     pulumi.String("name"),
    			Networking: &container.AwsClusterNetworkingArgs{
    				PodAddressCidrBlocks: pulumi.StringArray{
    					pulumi.String("10.2.0.0/16"),
    				},
    				ServiceAddressCidrBlocks: pulumi.StringArray{
    					pulumi.String("10.1.0.0/16"),
    				},
    				VpcId: pulumi.String("vpc-00000000000000000"),
    			},
    			Annotations: pulumi.StringMap{
    				"label-one": pulumi.String("value-one"),
    			},
    			Description: pulumi.String("A sample aws cluster"),
    			Project:     pulumi.String("my-project-name"),
    		})
    		if err != nil {
    			return err
    		}
    		_, err = container.NewAwsNodePool(ctx, "primary", &container.AwsNodePoolArgs{
    			Autoscaling: &container.AwsNodePoolAutoscalingArgs{
    				MaxNodeCount: pulumi.Int(5),
    				MinNodeCount: pulumi.Int(1),
    			},
    			Cluster: primary.Name,
    			Config: &container.AwsNodePoolConfigArgs{
    				ConfigEncryption: &container.AwsNodePoolConfigConfigEncryptionArgs{
    					KmsKeyArn: pulumi.String("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111"),
    				},
    				IamInstanceProfile: pulumi.String("my--1p-dev-nodepool"),
    				InstanceType:       pulumi.String("t3.medium"),
    				Labels: pulumi.StringMap{
    					"label-one": pulumi.String("value-one"),
    				},
    				RootVolume: &container.AwsNodePoolConfigRootVolumeArgs{
    					Iops:       pulumi.Int(3000),
    					KmsKeyArn:  pulumi.String("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111"),
    					SizeGib:    pulumi.Int(10),
    					VolumeType: pulumi.String("gp3"),
    				},
    				SecurityGroupIds: pulumi.StringArray{
    					pulumi.String("sg-00000000000000000"),
    				},
    				ProxyConfig: &container.AwsNodePoolConfigProxyConfigArgs{
    					SecretArn:     pulumi.String("arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF"),
    					SecretVersion: pulumi.String("12345678-ABCD-EFGH-IJKL-987654321098"),
    				},
    				SshConfig: &container.AwsNodePoolConfigSshConfigArgs{
    					Ec2KeyPair: pulumi.String("my--1p-dev-ssh"),
    				},
    				Tags: pulumi.StringMap{
    					"tag-one": pulumi.String("value-one"),
    				},
    				Taints: container.AwsNodePoolConfigTaintArray{
    					&container.AwsNodePoolConfigTaintArgs{
    						Effect: pulumi.String("prefer_no_schedule"),
    						Key:    pulumi.String("taint-key"),
    						Value:  pulumi.String("taint-value"),
    					},
    				},
    				InstancePlacement: &container.AwsNodePoolConfigInstancePlacementArgs{
    					Tenancy: pulumi.String("dedicated"),
    				},
    				ImageType: pulumi.String("ubuntu"),
    			},
    			Location: pulumi.String("us-west1"),
    			MaxPodsConstraint: &container.AwsNodePoolMaxPodsConstraintArgs{
    				MaxPodsPerNode: pulumi.Int(110),
    			},
    			Name:     pulumi.String("node-pool-name"),
    			SubnetId: pulumi.String("subnet-00000000000000000"),
    			Version:  pulumi.String(versions.ValidVersions[0]),
    			Annotations: pulumi.StringMap{
    				"label-one": pulumi.String("value-one"),
    			},
    			Project: pulumi.String("my-project-name"),
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using Pulumi;
    using Gcp = Pulumi.Gcp;
    
    return await Deployment.RunAsync(() => 
    {
        var versions = Gcp.Container.GetAwsVersions.Invoke(new()
        {
            Project = "my-project-name",
            Location = "us-west1",
        });
    
        var primary = new Gcp.Container.AwsCluster("primary", new()
        {
            Authorization = new Gcp.Container.Inputs.AwsClusterAuthorizationArgs
            {
                AdminUsers = new[]
                {
                    new Gcp.Container.Inputs.AwsClusterAuthorizationAdminUserArgs
                    {
                        Username = "my@service-account.com",
                    },
                },
            },
            AwsRegion = "my-aws-region",
            ControlPlane = new Gcp.Container.Inputs.AwsClusterControlPlaneArgs
            {
                AwsServicesAuthentication = new Gcp.Container.Inputs.AwsClusterControlPlaneAwsServicesAuthenticationArgs
                {
                    RoleArn = "arn:aws:iam::012345678910:role/my--1p-dev-oneplatform",
                    RoleSessionName = "my--1p-dev-session",
                },
                ConfigEncryption = new Gcp.Container.Inputs.AwsClusterControlPlaneConfigEncryptionArgs
                {
                    KmsKeyArn = "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                },
                DatabaseEncryption = new Gcp.Container.Inputs.AwsClusterControlPlaneDatabaseEncryptionArgs
                {
                    KmsKeyArn = "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                },
                IamInstanceProfile = "my--1p-dev-controlplane",
                SubnetIds = new[]
                {
                    "subnet-00000000000000000",
                },
                Version = versions.Apply(getAwsVersionsResult => getAwsVersionsResult.ValidVersions[0]),
                InstanceType = "t3.medium",
                MainVolume = new Gcp.Container.Inputs.AwsClusterControlPlaneMainVolumeArgs
                {
                    Iops = 3000,
                    KmsKeyArn = "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                    SizeGib = 10,
                    VolumeType = "GP3",
                },
                ProxyConfig = new Gcp.Container.Inputs.AwsClusterControlPlaneProxyConfigArgs
                {
                    SecretArn = "arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF",
                    SecretVersion = "12345678-ABCD-EFGH-IJKL-987654321098",
                },
                RootVolume = new Gcp.Container.Inputs.AwsClusterControlPlaneRootVolumeArgs
                {
                    Iops = 3000,
                    KmsKeyArn = "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                    SizeGib = 10,
                    VolumeType = "GP3",
                },
                SecurityGroupIds = new[]
                {
                    "sg-00000000000000000",
                },
                SshConfig = new Gcp.Container.Inputs.AwsClusterControlPlaneSshConfigArgs
                {
                    Ec2KeyPair = "my--1p-dev-ssh",
                },
                Tags = 
                {
                    { "owner", "my@service-account.com" },
                },
            },
            Fleet = new Gcp.Container.Inputs.AwsClusterFleetArgs
            {
                Project = "my-project-number",
            },
            Location = "us-west1",
            Name = "name",
            Networking = new Gcp.Container.Inputs.AwsClusterNetworkingArgs
            {
                PodAddressCidrBlocks = new[]
                {
                    "10.2.0.0/16",
                },
                ServiceAddressCidrBlocks = new[]
                {
                    "10.1.0.0/16",
                },
                VpcId = "vpc-00000000000000000",
            },
            Annotations = 
            {
                { "label-one", "value-one" },
            },
            Description = "A sample aws cluster",
            Project = "my-project-name",
        });
    
        var primaryAwsNodePool = new Gcp.Container.AwsNodePool("primary", new()
        {
            Autoscaling = new Gcp.Container.Inputs.AwsNodePoolAutoscalingArgs
            {
                MaxNodeCount = 5,
                MinNodeCount = 1,
            },
            Cluster = primary.Name,
            Config = new Gcp.Container.Inputs.AwsNodePoolConfigArgs
            {
                ConfigEncryption = new Gcp.Container.Inputs.AwsNodePoolConfigConfigEncryptionArgs
                {
                    KmsKeyArn = "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                },
                IamInstanceProfile = "my--1p-dev-nodepool",
                InstanceType = "t3.medium",
                Labels = 
                {
                    { "label-one", "value-one" },
                },
                RootVolume = new Gcp.Container.Inputs.AwsNodePoolConfigRootVolumeArgs
                {
                    Iops = 3000,
                    KmsKeyArn = "arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111",
                    SizeGib = 10,
                    VolumeType = "gp3",
                },
                SecurityGroupIds = new[]
                {
                    "sg-00000000000000000",
                },
                ProxyConfig = new Gcp.Container.Inputs.AwsNodePoolConfigProxyConfigArgs
                {
                    SecretArn = "arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF",
                    SecretVersion = "12345678-ABCD-EFGH-IJKL-987654321098",
                },
                SshConfig = new Gcp.Container.Inputs.AwsNodePoolConfigSshConfigArgs
                {
                    Ec2KeyPair = "my--1p-dev-ssh",
                },
                Tags = 
                {
                    { "tag-one", "value-one" },
                },
                Taints = new[]
                {
                    new Gcp.Container.Inputs.AwsNodePoolConfigTaintArgs
                    {
                        Effect = "prefer_no_schedule",
                        Key = "taint-key",
                        Value = "taint-value",
                    },
                },
                InstancePlacement = new Gcp.Container.Inputs.AwsNodePoolConfigInstancePlacementArgs
                {
                    Tenancy = "dedicated",
                },
                ImageType = "ubuntu",
            },
            Location = "us-west1",
            MaxPodsConstraint = new Gcp.Container.Inputs.AwsNodePoolMaxPodsConstraintArgs
            {
                MaxPodsPerNode = 110,
            },
            Name = "node-pool-name",
            SubnetId = "subnet-00000000000000000",
            Version = versions.Apply(getAwsVersionsResult => getAwsVersionsResult.ValidVersions[0]),
            Annotations = 
            {
                { "label-one", "value-one" },
            },
            Project = "my-project-name",
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.gcp.container.ContainerFunctions;
    import com.pulumi.gcp.container.inputs.GetAwsVersionsArgs;
    import com.pulumi.gcp.container.AwsCluster;
    import com.pulumi.gcp.container.AwsClusterArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterAuthorizationArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterControlPlaneArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterControlPlaneAwsServicesAuthenticationArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterControlPlaneConfigEncryptionArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterControlPlaneDatabaseEncryptionArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterControlPlaneMainVolumeArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterControlPlaneProxyConfigArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterControlPlaneRootVolumeArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterControlPlaneSshConfigArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterFleetArgs;
    import com.pulumi.gcp.container.inputs.AwsClusterNetworkingArgs;
    import com.pulumi.gcp.container.AwsNodePool;
    import com.pulumi.gcp.container.AwsNodePoolArgs;
    import com.pulumi.gcp.container.inputs.AwsNodePoolAutoscalingArgs;
    import com.pulumi.gcp.container.inputs.AwsNodePoolConfigArgs;
    import com.pulumi.gcp.container.inputs.AwsNodePoolConfigConfigEncryptionArgs;
    import com.pulumi.gcp.container.inputs.AwsNodePoolConfigRootVolumeArgs;
    import com.pulumi.gcp.container.inputs.AwsNodePoolConfigProxyConfigArgs;
    import com.pulumi.gcp.container.inputs.AwsNodePoolConfigSshConfigArgs;
    import com.pulumi.gcp.container.inputs.AwsNodePoolConfigInstancePlacementArgs;
    import com.pulumi.gcp.container.inputs.AwsNodePoolMaxPodsConstraintArgs;
    import java.util.List;
    import java.util.ArrayList;
    import java.util.Map;
    import java.io.File;
    import java.nio.file.Files;
    import java.nio.file.Paths;
    
    public class App {
        public static void main(String[] args) {
            Pulumi.run(App::stack);
        }
    
        public static void stack(Context ctx) {
            final var versions = ContainerFunctions.getAwsVersions(GetAwsVersionsArgs.builder()
                .project("my-project-name")
                .location("us-west1")
                .build());
    
            var primary = new AwsCluster("primary", AwsClusterArgs.builder()
                .authorization(AwsClusterAuthorizationArgs.builder()
                    .adminUsers(AwsClusterAuthorizationAdminUserArgs.builder()
                        .username("my@service-account.com")
                        .build())
                    .build())
                .awsRegion("my-aws-region")
                .controlPlane(AwsClusterControlPlaneArgs.builder()
                    .awsServicesAuthentication(AwsClusterControlPlaneAwsServicesAuthenticationArgs.builder()
                        .roleArn("arn:aws:iam::012345678910:role/my--1p-dev-oneplatform")
                        .roleSessionName("my--1p-dev-session")
                        .build())
                    .configEncryption(AwsClusterControlPlaneConfigEncryptionArgs.builder()
                        .kmsKeyArn("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111")
                        .build())
                    .databaseEncryption(AwsClusterControlPlaneDatabaseEncryptionArgs.builder()
                        .kmsKeyArn("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111")
                        .build())
                    .iamInstanceProfile("my--1p-dev-controlplane")
                    .subnetIds("subnet-00000000000000000")
                    .version(versions.applyValue(getAwsVersionsResult -> getAwsVersionsResult.validVersions()[0]))
                    .instanceType("t3.medium")
                    .mainVolume(AwsClusterControlPlaneMainVolumeArgs.builder()
                        .iops(3000)
                        .kmsKeyArn("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111")
                        .sizeGib(10)
                        .volumeType("GP3")
                        .build())
                    .proxyConfig(AwsClusterControlPlaneProxyConfigArgs.builder()
                        .secretArn("arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF")
                        .secretVersion("12345678-ABCD-EFGH-IJKL-987654321098")
                        .build())
                    .rootVolume(AwsClusterControlPlaneRootVolumeArgs.builder()
                        .iops(3000)
                        .kmsKeyArn("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111")
                        .sizeGib(10)
                        .volumeType("GP3")
                        .build())
                    .securityGroupIds("sg-00000000000000000")
                    .sshConfig(AwsClusterControlPlaneSshConfigArgs.builder()
                        .ec2KeyPair("my--1p-dev-ssh")
                        .build())
                    .tags(Map.of("owner", "my@service-account.com"))
                    .build())
                .fleet(AwsClusterFleetArgs.builder()
                    .project("my-project-number")
                    .build())
                .location("us-west1")
                .name("name")
                .networking(AwsClusterNetworkingArgs.builder()
                    .podAddressCidrBlocks("10.2.0.0/16")
                    .serviceAddressCidrBlocks("10.1.0.0/16")
                    .vpcId("vpc-00000000000000000")
                    .build())
                .annotations(Map.of("label-one", "value-one"))
                .description("A sample aws cluster")
                .project("my-project-name")
                .build());
    
            var primaryAwsNodePool = new AwsNodePool("primaryAwsNodePool", AwsNodePoolArgs.builder()
                .autoscaling(AwsNodePoolAutoscalingArgs.builder()
                    .maxNodeCount(5)
                    .minNodeCount(1)
                    .build())
                .cluster(primary.name())
                .config(AwsNodePoolConfigArgs.builder()
                    .configEncryption(AwsNodePoolConfigConfigEncryptionArgs.builder()
                        .kmsKeyArn("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111")
                        .build())
                    .iamInstanceProfile("my--1p-dev-nodepool")
                    .instanceType("t3.medium")
                    .labels(Map.of("label-one", "value-one"))
                    .rootVolume(AwsNodePoolConfigRootVolumeArgs.builder()
                        .iops(3000)
                        .kmsKeyArn("arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111")
                        .sizeGib(10)
                        .volumeType("gp3")
                        .build())
                    .securityGroupIds("sg-00000000000000000")
                    .proxyConfig(AwsNodePoolConfigProxyConfigArgs.builder()
                        .secretArn("arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF")
                        .secretVersion("12345678-ABCD-EFGH-IJKL-987654321098")
                        .build())
                    .sshConfig(AwsNodePoolConfigSshConfigArgs.builder()
                        .ec2KeyPair("my--1p-dev-ssh")
                        .build())
                    .tags(Map.of("tag-one", "value-one"))
                    .taints(AwsNodePoolConfigTaintArgs.builder()
                        .effect("prefer_no_schedule")
                        .key("taint-key")
                        .value("taint-value")
                        .build())
                    .instancePlacement(AwsNodePoolConfigInstancePlacementArgs.builder()
                        .tenancy("dedicated")
                        .build())
                    .imageType("ubuntu")
                    .build())
                .location("us-west1")
                .maxPodsConstraint(AwsNodePoolMaxPodsConstraintArgs.builder()
                    .maxPodsPerNode(110)
                    .build())
                .name("node-pool-name")
                .subnetId("subnet-00000000000000000")
                .version(versions.applyValue(getAwsVersionsResult -> getAwsVersionsResult.validVersions()[0]))
                .annotations(Map.of("label-one", "value-one"))
                .project("my-project-name")
                .build());
    
        }
    }
    
    resources:
      primary:
        type: gcp:container:AwsCluster
        properties:
          authorization:
            adminUsers:
              - username: my@service-account.com
          awsRegion: my-aws-region
          controlPlane:
            awsServicesAuthentication:
              roleArn: arn:aws:iam::012345678910:role/my--1p-dev-oneplatform
              roleSessionName: my--1p-dev-session
            configEncryption:
              kmsKeyArn: arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111
            databaseEncryption:
              kmsKeyArn: arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111
            iamInstanceProfile: my--1p-dev-controlplane
            subnetIds:
              - subnet-00000000000000000
            version: ${versions.validVersions[0]}
            instanceType: t3.medium
            mainVolume:
              iops: 3000
              kmsKeyArn: arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111
              sizeGib: 10
              volumeType: GP3
            proxyConfig:
              secretArn: arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF
              secretVersion: 12345678-ABCD-EFGH-IJKL-987654321098
            rootVolume:
              iops: 3000
              kmsKeyArn: arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111
              sizeGib: 10
              volumeType: GP3
            securityGroupIds:
              - sg-00000000000000000
            sshConfig:
              ec2KeyPair: my--1p-dev-ssh
            tags:
              owner: my@service-account.com
          fleet:
            project: my-project-number
          location: us-west1
          name: name
          networking:
            podAddressCidrBlocks:
              - 10.2.0.0/16
            serviceAddressCidrBlocks:
              - 10.1.0.0/16
            vpcId: vpc-00000000000000000
          annotations:
            label-one: value-one
          description: A sample aws cluster
          project: my-project-name
      primaryAwsNodePool:
        type: gcp:container:AwsNodePool
        name: primary
        properties:
          autoscaling:
            maxNodeCount: 5
            minNodeCount: 1
          cluster: ${primary.name}
          config:
            configEncryption:
              kmsKeyArn: arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111
            iamInstanceProfile: my--1p-dev-nodepool
            instanceType: t3.medium
            labels:
              label-one: value-one
            rootVolume:
              iops: 3000
              kmsKeyArn: arn:aws:kms:my-aws-region:012345678910:key/12345678-1234-1234-1234-123456789111
              sizeGib: 10
              volumeType: gp3
            securityGroupIds:
              - sg-00000000000000000
            proxyConfig:
              secretArn: arn:aws:secretsmanager:us-west-2:126285863215:secret:proxy_config20210824150329476300000001-ABCDEF
              secretVersion: 12345678-ABCD-EFGH-IJKL-987654321098
            sshConfig:
              ec2KeyPair: my--1p-dev-ssh
            tags:
              tag-one: value-one
            taints:
              - effect: prefer_no_schedule
                key: taint-key
                value: taint-value
            instancePlacement:
              tenancy: dedicated
            imageType: ubuntu
          location: us-west1
          maxPodsConstraint:
            maxPodsPerNode: 110
          name: node-pool-name
          subnetId: subnet-00000000000000000
          version: ${versions.validVersions[0]}
          annotations:
            label-one: value-one
          project: my-project-name
    variables:
      versions:
        fn::invoke:
          Function: gcp:container:getAwsVersions
          Arguments:
            project: my-project-name
            location: us-west1
    

    Create AwsNodePool Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new AwsNodePool(name: string, args: AwsNodePoolArgs, opts?: CustomResourceOptions);
    @overload
    def AwsNodePool(resource_name: str,
                    args: AwsNodePoolArgs,
                    opts: Optional[ResourceOptions] = None)
    
    @overload
    def AwsNodePool(resource_name: str,
                    opts: Optional[ResourceOptions] = None,
                    autoscaling: Optional[AwsNodePoolAutoscalingArgs] = None,
                    cluster: Optional[str] = None,
                    config: Optional[AwsNodePoolConfigArgs] = None,
                    location: Optional[str] = None,
                    max_pods_constraint: Optional[AwsNodePoolMaxPodsConstraintArgs] = None,
                    subnet_id: Optional[str] = None,
                    version: Optional[str] = None,
                    annotations: Optional[Mapping[str, str]] = None,
                    management: Optional[AwsNodePoolManagementArgs] = None,
                    name: Optional[str] = None,
                    project: Optional[str] = None,
                    update_settings: Optional[AwsNodePoolUpdateSettingsArgs] = None)
    func NewAwsNodePool(ctx *Context, name string, args AwsNodePoolArgs, opts ...ResourceOption) (*AwsNodePool, error)
    public AwsNodePool(string name, AwsNodePoolArgs args, CustomResourceOptions? opts = null)
    public AwsNodePool(String name, AwsNodePoolArgs args)
    public AwsNodePool(String name, AwsNodePoolArgs args, CustomResourceOptions options)
    
    type: gcp:container:AwsNodePool
    properties: # The arguments to resource properties.
    options: # Bag of options to control resource's behavior.
    
    

    Parameters

    name string
    The unique name of the resource.
    args AwsNodePoolArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args AwsNodePoolArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args AwsNodePoolArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args AwsNodePoolArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args AwsNodePoolArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Example

    The following reference example uses placeholder values for all input properties.

    var awsNodePoolResource = new Gcp.Container.AwsNodePool("awsNodePoolResource", new()
    {
        Autoscaling = new Gcp.Container.Inputs.AwsNodePoolAutoscalingArgs
        {
            MaxNodeCount = 0,
            MinNodeCount = 0,
        },
        Cluster = "string",
        Config = new Gcp.Container.Inputs.AwsNodePoolConfigArgs
        {
            IamInstanceProfile = "string",
            ConfigEncryption = new Gcp.Container.Inputs.AwsNodePoolConfigConfigEncryptionArgs
            {
                KmsKeyArn = "string",
            },
            Labels = 
            {
                { "string", "string" },
            },
            ImageType = "string",
            InstancePlacement = new Gcp.Container.Inputs.AwsNodePoolConfigInstancePlacementArgs
            {
                Tenancy = "string",
            },
            InstanceType = "string",
            AutoscalingMetricsCollection = new Gcp.Container.Inputs.AwsNodePoolConfigAutoscalingMetricsCollectionArgs
            {
                Granularity = "string",
                Metrics = new[]
                {
                    "string",
                },
            },
            ProxyConfig = new Gcp.Container.Inputs.AwsNodePoolConfigProxyConfigArgs
            {
                SecretArn = "string",
                SecretVersion = "string",
            },
            RootVolume = new Gcp.Container.Inputs.AwsNodePoolConfigRootVolumeArgs
            {
                Iops = 0,
                KmsKeyArn = "string",
                SizeGib = 0,
                Throughput = 0,
                VolumeType = "string",
            },
            SecurityGroupIds = new[]
            {
                "string",
            },
            SpotConfig = new Gcp.Container.Inputs.AwsNodePoolConfigSpotConfigArgs
            {
                InstanceTypes = new[]
                {
                    "string",
                },
            },
            SshConfig = new Gcp.Container.Inputs.AwsNodePoolConfigSshConfigArgs
            {
                Ec2KeyPair = "string",
            },
            Tags = 
            {
                { "string", "string" },
            },
            Taints = new[]
            {
                new Gcp.Container.Inputs.AwsNodePoolConfigTaintArgs
                {
                    Effect = "string",
                    Key = "string",
                    Value = "string",
                },
            },
        },
        Location = "string",
        MaxPodsConstraint = new Gcp.Container.Inputs.AwsNodePoolMaxPodsConstraintArgs
        {
            MaxPodsPerNode = 0,
        },
        SubnetId = "string",
        Version = "string",
        Annotations = 
        {
            { "string", "string" },
        },
        Management = new Gcp.Container.Inputs.AwsNodePoolManagementArgs
        {
            AutoRepair = false,
        },
        Name = "string",
        Project = "string",
        UpdateSettings = new Gcp.Container.Inputs.AwsNodePoolUpdateSettingsArgs
        {
            SurgeSettings = new Gcp.Container.Inputs.AwsNodePoolUpdateSettingsSurgeSettingsArgs
            {
                MaxSurge = 0,
                MaxUnavailable = 0,
            },
        },
    });
    
    example, err := container.NewAwsNodePool(ctx, "awsNodePoolResource", &container.AwsNodePoolArgs{
    	Autoscaling: &container.AwsNodePoolAutoscalingArgs{
    		MaxNodeCount: pulumi.Int(0),
    		MinNodeCount: pulumi.Int(0),
    	},
    	Cluster: pulumi.String("string"),
    	Config: &container.AwsNodePoolConfigArgs{
    		IamInstanceProfile: pulumi.String("string"),
    		ConfigEncryption: &container.AwsNodePoolConfigConfigEncryptionArgs{
    			KmsKeyArn: pulumi.String("string"),
    		},
    		Labels: pulumi.StringMap{
    			"string": pulumi.String("string"),
    		},
    		ImageType: pulumi.String("string"),
    		InstancePlacement: &container.AwsNodePoolConfigInstancePlacementArgs{
    			Tenancy: pulumi.String("string"),
    		},
    		InstanceType: pulumi.String("string"),
    		AutoscalingMetricsCollection: &container.AwsNodePoolConfigAutoscalingMetricsCollectionArgs{
    			Granularity: pulumi.String("string"),
    			Metrics: pulumi.StringArray{
    				pulumi.String("string"),
    			},
    		},
    		ProxyConfig: &container.AwsNodePoolConfigProxyConfigArgs{
    			SecretArn:     pulumi.String("string"),
    			SecretVersion: pulumi.String("string"),
    		},
    		RootVolume: &container.AwsNodePoolConfigRootVolumeArgs{
    			Iops:       pulumi.Int(0),
    			KmsKeyArn:  pulumi.String("string"),
    			SizeGib:    pulumi.Int(0),
    			Throughput: pulumi.Int(0),
    			VolumeType: pulumi.String("string"),
    		},
    		SecurityGroupIds: pulumi.StringArray{
    			pulumi.String("string"),
    		},
    		SpotConfig: &container.AwsNodePoolConfigSpotConfigArgs{
    			InstanceTypes: pulumi.StringArray{
    				pulumi.String("string"),
    			},
    		},
    		SshConfig: &container.AwsNodePoolConfigSshConfigArgs{
    			Ec2KeyPair: pulumi.String("string"),
    		},
    		Tags: pulumi.StringMap{
    			"string": pulumi.String("string"),
    		},
    		Taints: container.AwsNodePoolConfigTaintArray{
    			&container.AwsNodePoolConfigTaintArgs{
    				Effect: pulumi.String("string"),
    				Key:    pulumi.String("string"),
    				Value:  pulumi.String("string"),
    			},
    		},
    	},
    	Location: pulumi.String("string"),
    	MaxPodsConstraint: &container.AwsNodePoolMaxPodsConstraintArgs{
    		MaxPodsPerNode: pulumi.Int(0),
    	},
    	SubnetId: pulumi.String("string"),
    	Version:  pulumi.String("string"),
    	Annotations: pulumi.StringMap{
    		"string": pulumi.String("string"),
    	},
    	Management: &container.AwsNodePoolManagementArgs{
    		AutoRepair: pulumi.Bool(false),
    	},
    	Name:    pulumi.String("string"),
    	Project: pulumi.String("string"),
    	UpdateSettings: &container.AwsNodePoolUpdateSettingsArgs{
    		SurgeSettings: &container.AwsNodePoolUpdateSettingsSurgeSettingsArgs{
    			MaxSurge:       pulumi.Int(0),
    			MaxUnavailable: pulumi.Int(0),
    		},
    	},
    })
    
    var awsNodePoolResource = new AwsNodePool("awsNodePoolResource", AwsNodePoolArgs.builder()
        .autoscaling(AwsNodePoolAutoscalingArgs.builder()
            .maxNodeCount(0)
            .minNodeCount(0)
            .build())
        .cluster("string")
        .config(AwsNodePoolConfigArgs.builder()
            .iamInstanceProfile("string")
            .configEncryption(AwsNodePoolConfigConfigEncryptionArgs.builder()
                .kmsKeyArn("string")
                .build())
            .labels(Map.of("string", "string"))
            .imageType("string")
            .instancePlacement(AwsNodePoolConfigInstancePlacementArgs.builder()
                .tenancy("string")
                .build())
            .instanceType("string")
            .autoscalingMetricsCollection(AwsNodePoolConfigAutoscalingMetricsCollectionArgs.builder()
                .granularity("string")
                .metrics("string")
                .build())
            .proxyConfig(AwsNodePoolConfigProxyConfigArgs.builder()
                .secretArn("string")
                .secretVersion("string")
                .build())
            .rootVolume(AwsNodePoolConfigRootVolumeArgs.builder()
                .iops(0)
                .kmsKeyArn("string")
                .sizeGib(0)
                .throughput(0)
                .volumeType("string")
                .build())
            .securityGroupIds("string")
            .spotConfig(AwsNodePoolConfigSpotConfigArgs.builder()
                .instanceTypes("string")
                .build())
            .sshConfig(AwsNodePoolConfigSshConfigArgs.builder()
                .ec2KeyPair("string")
                .build())
            .tags(Map.of("string", "string"))
            .taints(AwsNodePoolConfigTaintArgs.builder()
                .effect("string")
                .key("string")
                .value("string")
                .build())
            .build())
        .location("string")
        .maxPodsConstraint(AwsNodePoolMaxPodsConstraintArgs.builder()
            .maxPodsPerNode(0)
            .build())
        .subnetId("string")
        .version("string")
        .annotations(Map.of("string", "string"))
        .management(AwsNodePoolManagementArgs.builder()
            .autoRepair(false)
            .build())
        .name("string")
        .project("string")
        .updateSettings(AwsNodePoolUpdateSettingsArgs.builder()
            .surgeSettings(AwsNodePoolUpdateSettingsSurgeSettingsArgs.builder()
                .maxSurge(0)
                .maxUnavailable(0)
                .build())
            .build())
        .build());
    
    aws_node_pool_resource = gcp.container.AwsNodePool("awsNodePoolResource",
        autoscaling=gcp.container.AwsNodePoolAutoscalingArgs(
            max_node_count=0,
            min_node_count=0,
        ),
        cluster="string",
        config=gcp.container.AwsNodePoolConfigArgs(
            iam_instance_profile="string",
            config_encryption=gcp.container.AwsNodePoolConfigConfigEncryptionArgs(
                kms_key_arn="string",
            ),
            labels={
                "string": "string",
            },
            image_type="string",
            instance_placement=gcp.container.AwsNodePoolConfigInstancePlacementArgs(
                tenancy="string",
            ),
            instance_type="string",
            autoscaling_metrics_collection=gcp.container.AwsNodePoolConfigAutoscalingMetricsCollectionArgs(
                granularity="string",
                metrics=["string"],
            ),
            proxy_config=gcp.container.AwsNodePoolConfigProxyConfigArgs(
                secret_arn="string",
                secret_version="string",
            ),
            root_volume=gcp.container.AwsNodePoolConfigRootVolumeArgs(
                iops=0,
                kms_key_arn="string",
                size_gib=0,
                throughput=0,
                volume_type="string",
            ),
            security_group_ids=["string"],
            spot_config=gcp.container.AwsNodePoolConfigSpotConfigArgs(
                instance_types=["string"],
            ),
            ssh_config=gcp.container.AwsNodePoolConfigSshConfigArgs(
                ec2_key_pair="string",
            ),
            tags={
                "string": "string",
            },
            taints=[gcp.container.AwsNodePoolConfigTaintArgs(
                effect="string",
                key="string",
                value="string",
            )],
        ),
        location="string",
        max_pods_constraint=gcp.container.AwsNodePoolMaxPodsConstraintArgs(
            max_pods_per_node=0,
        ),
        subnet_id="string",
        version="string",
        annotations={
            "string": "string",
        },
        management=gcp.container.AwsNodePoolManagementArgs(
            auto_repair=False,
        ),
        name="string",
        project="string",
        update_settings=gcp.container.AwsNodePoolUpdateSettingsArgs(
            surge_settings=gcp.container.AwsNodePoolUpdateSettingsSurgeSettingsArgs(
                max_surge=0,
                max_unavailable=0,
            ),
        ))
    
    const awsNodePoolResource = new gcp.container.AwsNodePool("awsNodePoolResource", {
        autoscaling: {
            maxNodeCount: 0,
            minNodeCount: 0,
        },
        cluster: "string",
        config: {
            iamInstanceProfile: "string",
            configEncryption: {
                kmsKeyArn: "string",
            },
            labels: {
                string: "string",
            },
            imageType: "string",
            instancePlacement: {
                tenancy: "string",
            },
            instanceType: "string",
            autoscalingMetricsCollection: {
                granularity: "string",
                metrics: ["string"],
            },
            proxyConfig: {
                secretArn: "string",
                secretVersion: "string",
            },
            rootVolume: {
                iops: 0,
                kmsKeyArn: "string",
                sizeGib: 0,
                throughput: 0,
                volumeType: "string",
            },
            securityGroupIds: ["string"],
            spotConfig: {
                instanceTypes: ["string"],
            },
            sshConfig: {
                ec2KeyPair: "string",
            },
            tags: {
                string: "string",
            },
            taints: [{
                effect: "string",
                key: "string",
                value: "string",
            }],
        },
        location: "string",
        maxPodsConstraint: {
            maxPodsPerNode: 0,
        },
        subnetId: "string",
        version: "string",
        annotations: {
            string: "string",
        },
        management: {
            autoRepair: false,
        },
        name: "string",
        project: "string",
        updateSettings: {
            surgeSettings: {
                maxSurge: 0,
                maxUnavailable: 0,
            },
        },
    });
    
    type: gcp:container:AwsNodePool
    properties:
        annotations:
            string: string
        autoscaling:
            maxNodeCount: 0
            minNodeCount: 0
        cluster: string
        config:
            autoscalingMetricsCollection:
                granularity: string
                metrics:
                    - string
            configEncryption:
                kmsKeyArn: string
            iamInstanceProfile: string
            imageType: string
            instancePlacement:
                tenancy: string
            instanceType: string
            labels:
                string: string
            proxyConfig:
                secretArn: string
                secretVersion: string
            rootVolume:
                iops: 0
                kmsKeyArn: string
                sizeGib: 0
                throughput: 0
                volumeType: string
            securityGroupIds:
                - string
            spotConfig:
                instanceTypes:
                    - string
            sshConfig:
                ec2KeyPair: string
            tags:
                string: string
            taints:
                - effect: string
                  key: string
                  value: string
        location: string
        management:
            autoRepair: false
        maxPodsConstraint:
            maxPodsPerNode: 0
        name: string
        project: string
        subnetId: string
        updateSettings:
            surgeSettings:
                maxSurge: 0
                maxUnavailable: 0
        version: string
    

    AwsNodePool Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    The AwsNodePool resource accepts the following input properties:

    Autoscaling AwsNodePoolAutoscaling
    Autoscaler configuration for this node pool.
    Cluster string
    The awsCluster for the resource
    Config AwsNodePoolConfig
    The configuration of the node pool.
    Location string
    The location for the resource
    MaxPodsConstraint AwsNodePoolMaxPodsConstraint
    The constraint on the maximum number of pods that can be run simultaneously on a node in the node pool.
    SubnetId string
    The subnet where the node pool node run.
    Version string
    The Kubernetes version to run on this node pool (e.g. 1.19.10-gke.1000). You can list all supported versions on a given Google Cloud region by calling GetAwsServerConfig.
    Annotations Dictionary<string, string>
    Optional. Annotations on the node pool. This field has the same restrictions as Kubernetes annotations. The total size of all keys and values combined is limited to 256k. Key can have 2 segments: prefix (optional) and name (required), separated by a slash (/). Prefix must be a DNS subdomain. Name must be 63 characters or less, begin and end with alphanumerics, with dashes (-), underscores (_), dots (.), and alphanumerics between. Note: This field is non-authoritative, and will only manage the annotations present in your configuration. Please refer to the field effective_annotations for all of the annotations present on the resource.
    Management AwsNodePoolManagement
    The Management configuration for this node pool.
    Name string
    The name of this resource.
    Project string
    The project for the resource
    UpdateSettings AwsNodePoolUpdateSettings
    Optional. Update settings control the speed and disruption of the node pool update.
    Autoscaling AwsNodePoolAutoscalingArgs
    Autoscaler configuration for this node pool.
    Cluster string
    The awsCluster for the resource
    Config AwsNodePoolConfigArgs
    The configuration of the node pool.
    Location string
    The location for the resource
    MaxPodsConstraint AwsNodePoolMaxPodsConstraintArgs
    The constraint on the maximum number of pods that can be run simultaneously on a node in the node pool.
    SubnetId string
    The subnet where the node pool node run.
    Version string
    The Kubernetes version to run on this node pool (e.g. 1.19.10-gke.1000). You can list all supported versions on a given Google Cloud region by calling GetAwsServerConfig.
    Annotations map[string]string
    Optional. Annotations on the node pool. This field has the same restrictions as Kubernetes annotations. The total size of all keys and values combined is limited to 256k. Key can have 2 segments: prefix (optional) and name (required), separated by a slash (/). Prefix must be a DNS subdomain. Name must be 63 characters or less, begin and end with alphanumerics, with dashes (-), underscores (_), dots (.), and alphanumerics between. Note: This field is non-authoritative, and will only manage the annotations present in your configuration. Please refer to the field effective_annotations for all of the annotations present on the resource.
    Management AwsNodePoolManagementArgs
    The Management configuration for this node pool.
    Name string
    The name of this resource.
    Project string
    The project for the resource
    UpdateSettings AwsNodePoolUpdateSettingsArgs
    Optional. Update settings control the speed and disruption of the node pool update.
    autoscaling AwsNodePoolAutoscaling
    Autoscaler configuration for this node pool.
    cluster String
    The awsCluster for the resource
    config AwsNodePoolConfig
    The configuration of the node pool.
    location String
    The location for the resource
    maxPodsConstraint AwsNodePoolMaxPodsConstraint
    The constraint on the maximum number of pods that can be run simultaneously on a node in the node pool.
    subnetId String
    The subnet where the node pool node run.
    version String
    The Kubernetes version to run on this node pool (e.g. 1.19.10-gke.1000). You can list all supported versions on a given Google Cloud region by calling GetAwsServerConfig.
    annotations Map<String,String>
    Optional. Annotations on the node pool. This field has the same restrictions as Kubernetes annotations. The total size of all keys and values combined is limited to 256k. Key can have 2 segments: prefix (optional) and name (required), separated by a slash (/). Prefix must be a DNS subdomain. Name must be 63 characters or less, begin and end with alphanumerics, with dashes (-), underscores (_), dots (.), and alphanumerics between. Note: This field is non-authoritative, and will only manage the annotations present in your configuration. Please refer to the field effective_annotations for all of the annotations present on the resource.
    management AwsNodePoolManagement
    The Management configuration for this node pool.
    name String
    The name of this resource.
    project String
    The project for the resource
    updateSettings AwsNodePoolUpdateSettings
    Optional. Update settings control the speed and disruption of the node pool update.
    autoscaling AwsNodePoolAutoscaling
    Autoscaler configuration for this node pool.
    cluster string
    The awsCluster for the resource
    config AwsNodePoolConfig
    The configuration of the node pool.
    location string
    The location for the resource
    maxPodsConstraint AwsNodePoolMaxPodsConstraint
    The constraint on the maximum number of pods that can be run simultaneously on a node in the node pool.
    subnetId string
    The subnet where the node pool node run.
    version string
    The Kubernetes version to run on this node pool (e.g. 1.19.10-gke.1000). You can list all supported versions on a given Google Cloud region by calling GetAwsServerConfig.
    annotations {[key: string]: string}
    Optional. Annotations on the node pool. This field has the same restrictions as Kubernetes annotations. The total size of all keys and values combined is limited to 256k. Key can have 2 segments: prefix (optional) and name (required), separated by a slash (/). Prefix must be a DNS subdomain. Name must be 63 characters or less, begin and end with alphanumerics, with dashes (-), underscores (_), dots (.), and alphanumerics between. Note: This field is non-authoritative, and will only manage the annotations present in your configuration. Please refer to the field effective_annotations for all of the annotations present on the resource.
    management AwsNodePoolManagement
    The Management configuration for this node pool.
    name string
    The name of this resource.
    project string
    The project for the resource
    updateSettings AwsNodePoolUpdateSettings
    Optional. Update settings control the speed and disruption of the node pool update.
    autoscaling AwsNodePoolAutoscalingArgs
    Autoscaler configuration for this node pool.
    cluster str
    The awsCluster for the resource
    config AwsNodePoolConfigArgs
    The configuration of the node pool.
    location str
    The location for the resource
    max_pods_constraint AwsNodePoolMaxPodsConstraintArgs
    The constraint on the maximum number of pods that can be run simultaneously on a node in the node pool.
    subnet_id str
    The subnet where the node pool node run.
    version str
    The Kubernetes version to run on this node pool (e.g. 1.19.10-gke.1000). You can list all supported versions on a given Google Cloud region by calling GetAwsServerConfig.
    annotations Mapping[str, str]
    Optional. Annotations on the node pool. This field has the same restrictions as Kubernetes annotations. The total size of all keys and values combined is limited to 256k. Key can have 2 segments: prefix (optional) and name (required), separated by a slash (/). Prefix must be a DNS subdomain. Name must be 63 characters or less, begin and end with alphanumerics, with dashes (-), underscores (_), dots (.), and alphanumerics between. Note: This field is non-authoritative, and will only manage the annotations present in your configuration. Please refer to the field effective_annotations for all of the annotations present on the resource.
    management AwsNodePoolManagementArgs
    The Management configuration for this node pool.
    name str
    The name of this resource.
    project str
    The project for the resource
    update_settings AwsNodePoolUpdateSettingsArgs
    Optional. Update settings control the speed and disruption of the node pool update.
    autoscaling Property Map
    Autoscaler configuration for this node pool.
    cluster String
    The awsCluster for the resource
    config Property Map
    The configuration of the node pool.
    location String
    The location for the resource
    maxPodsConstraint Property Map
    The constraint on the maximum number of pods that can be run simultaneously on a node in the node pool.
    subnetId String
    The subnet where the node pool node run.
    version String
    The Kubernetes version to run on this node pool (e.g. 1.19.10-gke.1000). You can list all supported versions on a given Google Cloud region by calling GetAwsServerConfig.
    annotations Map<String>
    Optional. Annotations on the node pool. This field has the same restrictions as Kubernetes annotations. The total size of all keys and values combined is limited to 256k. Key can have 2 segments: prefix (optional) and name (required), separated by a slash (/). Prefix must be a DNS subdomain. Name must be 63 characters or less, begin and end with alphanumerics, with dashes (-), underscores (_), dots (.), and alphanumerics between. Note: This field is non-authoritative, and will only manage the annotations present in your configuration. Please refer to the field effective_annotations for all of the annotations present on the resource.
    management Property Map
    The Management configuration for this node pool.
    name String
    The name of this resource.
    project String
    The project for the resource
    updateSettings Property Map
    Optional. Update settings control the speed and disruption of the node pool update.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the AwsNodePool resource produces the following output properties:

    CreateTime string
    Output only. The time at which this node pool was created.
    EffectiveAnnotations Dictionary<string, object>
    Etag string
    Allows clients to perform consistent read-modify-writes through optimistic concurrency control. May be sent on update and delete requests to ensure the client has an up-to-date value before proceeding.
    Id string
    The provider-assigned unique ID for this managed resource.
    Reconciling bool
    Output only. If set, there are currently changes in flight to the node pool.
    State string
    Output only. The lifecycle state of the node pool. Possible values: STATE_UNSPECIFIED, PROVISIONING, RUNNING, RECONCILING, STOPPING, ERROR, DEGRADED
    Uid string
    Output only. A globally unique identifier for the node pool.
    UpdateTime string
    Output only. The time at which this node pool was last updated.
    CreateTime string
    Output only. The time at which this node pool was created.
    EffectiveAnnotations map[string]interface{}
    Etag string
    Allows clients to perform consistent read-modify-writes through optimistic concurrency control. May be sent on update and delete requests to ensure the client has an up-to-date value before proceeding.
    Id string
    The provider-assigned unique ID for this managed resource.
    Reconciling bool
    Output only. If set, there are currently changes in flight to the node pool.
    State string
    Output only. The lifecycle state of the node pool. Possible values: STATE_UNSPECIFIED, PROVISIONING, RUNNING, RECONCILING, STOPPING, ERROR, DEGRADED
    Uid string
    Output only. A globally unique identifier for the node pool.
    UpdateTime string
    Output only. The time at which this node pool was last updated.
    createTime String
    Output only. The time at which this node pool was created.
    effectiveAnnotations Map<String,Object>
    etag String
    Allows clients to perform consistent read-modify-writes through optimistic concurrency control. May be sent on update and delete requests to ensure the client has an up-to-date value before proceeding.
    id String
    The provider-assigned unique ID for this managed resource.
    reconciling Boolean
    Output only. If set, there are currently changes in flight to the node pool.
    state String
    Output only. The lifecycle state of the node pool. Possible values: STATE_UNSPECIFIED, PROVISIONING, RUNNING, RECONCILING, STOPPING, ERROR, DEGRADED
    uid String
    Output only. A globally unique identifier for the node pool.
    updateTime String
    Output only. The time at which this node pool was last updated.
    createTime string
    Output only. The time at which this node pool was created.
    effectiveAnnotations {[key: string]: any}
    etag string
    Allows clients to perform consistent read-modify-writes through optimistic concurrency control. May be sent on update and delete requests to ensure the client has an up-to-date value before proceeding.
    id string
    The provider-assigned unique ID for this managed resource.
    reconciling boolean
    Output only. If set, there are currently changes in flight to the node pool.
    state string
    Output only. The lifecycle state of the node pool. Possible values: STATE_UNSPECIFIED, PROVISIONING, RUNNING, RECONCILING, STOPPING, ERROR, DEGRADED
    uid string
    Output only. A globally unique identifier for the node pool.
    updateTime string
    Output only. The time at which this node pool was last updated.
    create_time str
    Output only. The time at which this node pool was created.
    effective_annotations Mapping[str, Any]
    etag str
    Allows clients to perform consistent read-modify-writes through optimistic concurrency control. May be sent on update and delete requests to ensure the client has an up-to-date value before proceeding.
    id str
    The provider-assigned unique ID for this managed resource.
    reconciling bool
    Output only. If set, there are currently changes in flight to the node pool.
    state str
    Output only. The lifecycle state of the node pool. Possible values: STATE_UNSPECIFIED, PROVISIONING, RUNNING, RECONCILING, STOPPING, ERROR, DEGRADED
    uid str
    Output only. A globally unique identifier for the node pool.
    update_time str
    Output only. The time at which this node pool was last updated.
    createTime String
    Output only. The time at which this node pool was created.
    effectiveAnnotations Map<Any>
    etag String
    Allows clients to perform consistent read-modify-writes through optimistic concurrency control. May be sent on update and delete requests to ensure the client has an up-to-date value before proceeding.
    id String
    The provider-assigned unique ID for this managed resource.
    reconciling Boolean
    Output only. If set, there are currently changes in flight to the node pool.
    state String
    Output only. The lifecycle state of the node pool. Possible values: STATE_UNSPECIFIED, PROVISIONING, RUNNING, RECONCILING, STOPPING, ERROR, DEGRADED
    uid String
    Output only. A globally unique identifier for the node pool.
    updateTime String
    Output only. The time at which this node pool was last updated.

    Look up Existing AwsNodePool Resource

    Get an existing AwsNodePool resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: AwsNodePoolState, opts?: CustomResourceOptions): AwsNodePool
    @staticmethod
    def get(resource_name: str,
            id: str,
            opts: Optional[ResourceOptions] = None,
            annotations: Optional[Mapping[str, str]] = None,
            autoscaling: Optional[AwsNodePoolAutoscalingArgs] = None,
            cluster: Optional[str] = None,
            config: Optional[AwsNodePoolConfigArgs] = None,
            create_time: Optional[str] = None,
            effective_annotations: Optional[Mapping[str, Any]] = None,
            etag: Optional[str] = None,
            location: Optional[str] = None,
            management: Optional[AwsNodePoolManagementArgs] = None,
            max_pods_constraint: Optional[AwsNodePoolMaxPodsConstraintArgs] = None,
            name: Optional[str] = None,
            project: Optional[str] = None,
            reconciling: Optional[bool] = None,
            state: Optional[str] = None,
            subnet_id: Optional[str] = None,
            uid: Optional[str] = None,
            update_settings: Optional[AwsNodePoolUpdateSettingsArgs] = None,
            update_time: Optional[str] = None,
            version: Optional[str] = None) -> AwsNodePool
    func GetAwsNodePool(ctx *Context, name string, id IDInput, state *AwsNodePoolState, opts ...ResourceOption) (*AwsNodePool, error)
    public static AwsNodePool Get(string name, Input<string> id, AwsNodePoolState? state, CustomResourceOptions? opts = null)
    public static AwsNodePool get(String name, Output<String> id, AwsNodePoolState state, CustomResourceOptions options)
    Resource lookup is not supported in YAML
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    Annotations Dictionary<string, string>
    Optional. Annotations on the node pool. This field has the same restrictions as Kubernetes annotations. The total size of all keys and values combined is limited to 256k. Key can have 2 segments: prefix (optional) and name (required), separated by a slash (/). Prefix must be a DNS subdomain. Name must be 63 characters or less, begin and end with alphanumerics, with dashes (-), underscores (_), dots (.), and alphanumerics between. Note: This field is non-authoritative, and will only manage the annotations present in your configuration. Please refer to the field effective_annotations for all of the annotations present on the resource.
    Autoscaling AwsNodePoolAutoscaling
    Autoscaler configuration for this node pool.
    Cluster string
    The awsCluster for the resource
    Config AwsNodePoolConfig
    The configuration of the node pool.
    CreateTime string
    Output only. The time at which this node pool was created.
    EffectiveAnnotations Dictionary<string, object>
    Etag string
    Allows clients to perform consistent read-modify-writes through optimistic concurrency control. May be sent on update and delete requests to ensure the client has an up-to-date value before proceeding.
    Location string
    The location for the resource
    Management AwsNodePoolManagement
    The Management configuration for this node pool.
    MaxPodsConstraint AwsNodePoolMaxPodsConstraint
    The constraint on the maximum number of pods that can be run simultaneously on a node in the node pool.
    Name string
    The name of this resource.
    Project string
    The project for the resource
    Reconciling bool
    Output only. If set, there are currently changes in flight to the node pool.
    State string
    Output only. The lifecycle state of the node pool. Possible values: STATE_UNSPECIFIED, PROVISIONING, RUNNING, RECONCILING, STOPPING, ERROR, DEGRADED
    SubnetId string
    The subnet where the node pool node run.
    Uid string
    Output only. A globally unique identifier for the node pool.
    UpdateSettings AwsNodePoolUpdateSettings
    Optional. Update settings control the speed and disruption of the node pool update.
    UpdateTime string
    Output only. The time at which this node pool was last updated.
    Version string
    The Kubernetes version to run on this node pool (e.g. 1.19.10-gke.1000). You can list all supported versions on a given Google Cloud region by calling GetAwsServerConfig.
    Annotations map[string]string
    Optional. Annotations on the node pool. This field has the same restrictions as Kubernetes annotations. The total size of all keys and values combined is limited to 256k. Key can have 2 segments: prefix (optional) and name (required), separated by a slash (/). Prefix must be a DNS subdomain. Name must be 63 characters or less, begin and end with alphanumerics, with dashes (-), underscores (_), dots (.), and alphanumerics between. Note: This field is non-authoritative, and will only manage the annotations present in your configuration. Please refer to the field effective_annotations for all of the annotations present on the resource.
    Autoscaling AwsNodePoolAutoscalingArgs
    Autoscaler configuration for this node pool.
    Cluster string
    The awsCluster for the resource
    Config AwsNodePoolConfigArgs
    The configuration of the node pool.
    CreateTime string
    Output only. The time at which this node pool was created.
    EffectiveAnnotations map[string]interface{}
    Etag string
    Allows clients to perform consistent read-modify-writes through optimistic concurrency control. May be sent on update and delete requests to ensure the client has an up-to-date value before proceeding.
    Location string
    The location for the resource
    Management AwsNodePoolManagementArgs
    The Management configuration for this node pool.
    MaxPodsConstraint AwsNodePoolMaxPodsConstraintArgs
    The constraint on the maximum number of pods that can be run simultaneously on a node in the node pool.
    Name string
    The name of this resource.
    Project string
    The project for the resource
    Reconciling bool
    Output only. If set, there are currently changes in flight to the node pool.
    State string
    Output only. The lifecycle state of the node pool. Possible values: STATE_UNSPECIFIED, PROVISIONING, RUNNING, RECONCILING, STOPPING, ERROR, DEGRADED
    SubnetId string
    The subnet where the node pool node run.
    Uid string
    Output only. A globally unique identifier for the node pool.
    UpdateSettings AwsNodePoolUpdateSettingsArgs
    Optional. Update settings control the speed and disruption of the node pool update.
    UpdateTime string
    Output only. The time at which this node pool was last updated.
    Version string
    The Kubernetes version to run on this node pool (e.g. 1.19.10-gke.1000). You can list all supported versions on a given Google Cloud region by calling GetAwsServerConfig.
    annotations Map<String,String>
    Optional. Annotations on the node pool. This field has the same restrictions as Kubernetes annotations. The total size of all keys and values combined is limited to 256k. Key can have 2 segments: prefix (optional) and name (required), separated by a slash (/). Prefix must be a DNS subdomain. Name must be 63 characters or less, begin and end with alphanumerics, with dashes (-), underscores (_), dots (.), and alphanumerics between. Note: This field is non-authoritative, and will only manage the annotations present in your configuration. Please refer to the field effective_annotations for all of the annotations present on the resource.
    autoscaling AwsNodePoolAutoscaling
    Autoscaler configuration for this node pool.
    cluster String
    The awsCluster for the resource
    config AwsNodePoolConfig
    The configuration of the node pool.
    createTime String
    Output only. The time at which this node pool was created.
    effectiveAnnotations Map<String,Object>
    etag String
    Allows clients to perform consistent read-modify-writes through optimistic concurrency control. May be sent on update and delete requests to ensure the client has an up-to-date value before proceeding.
    location String
    The location for the resource
    management AwsNodePoolManagement
    The Management configuration for this node pool.
    maxPodsConstraint AwsNodePoolMaxPodsConstraint
    The constraint on the maximum number of pods that can be run simultaneously on a node in the node pool.
    name String
    The name of this resource.
    project String
    The project for the resource
    reconciling Boolean
    Output only. If set, there are currently changes in flight to the node pool.
    state String
    Output only. The lifecycle state of the node pool. Possible values: STATE_UNSPECIFIED, PROVISIONING, RUNNING, RECONCILING, STOPPING, ERROR, DEGRADED
    subnetId String
    The subnet where the node pool node run.
    uid String
    Output only. A globally unique identifier for the node pool.
    updateSettings AwsNodePoolUpdateSettings
    Optional. Update settings control the speed and disruption of the node pool update.
    updateTime String
    Output only. The time at which this node pool was last updated.
    version String
    The Kubernetes version to run on this node pool (e.g. 1.19.10-gke.1000). You can list all supported versions on a given Google Cloud region by calling GetAwsServerConfig.
    annotations {[key: string]: string}
    Optional. Annotations on the node pool. This field has the same restrictions as Kubernetes annotations. The total size of all keys and values combined is limited to 256k. Key can have 2 segments: prefix (optional) and name (required), separated by a slash (/). Prefix must be a DNS subdomain. Name must be 63 characters or less, begin and end with alphanumerics, with dashes (-), underscores (_), dots (.), and alphanumerics between. Note: This field is non-authoritative, and will only manage the annotations present in your configuration. Please refer to the field effective_annotations for all of the annotations present on the resource.
    autoscaling AwsNodePoolAutoscaling
    Autoscaler configuration for this node pool.
    cluster string
    The awsCluster for the resource
    config AwsNodePoolConfig
    The configuration of the node pool.
    createTime string
    Output only. The time at which this node pool was created.
    effectiveAnnotations {[key: string]: any}
    etag string
    Allows clients to perform consistent read-modify-writes through optimistic concurrency control. May be sent on update and delete requests to ensure the client has an up-to-date value before proceeding.
    location string
    The location for the resource
    management AwsNodePoolManagement
    The Management configuration for this node pool.
    maxPodsConstraint AwsNodePoolMaxPodsConstraint
    The constraint on the maximum number of pods that can be run simultaneously on a node in the node pool.
    name string
    The name of this resource.
    project string
    The project for the resource
    reconciling boolean
    Output only. If set, there are currently changes in flight to the node pool.
    state string
    Output only. The lifecycle state of the node pool. Possible values: STATE_UNSPECIFIED, PROVISIONING, RUNNING, RECONCILING, STOPPING, ERROR, DEGRADED
    subnetId string
    The subnet where the node pool node run.
    uid string
    Output only. A globally unique identifier for the node pool.
    updateSettings AwsNodePoolUpdateSettings
    Optional. Update settings control the speed and disruption of the node pool update.
    updateTime string
    Output only. The time at which this node pool was last updated.
    version string
    The Kubernetes version to run on this node pool (e.g. 1.19.10-gke.1000). You can list all supported versions on a given Google Cloud region by calling GetAwsServerConfig.
    annotations Mapping[str, str]
    Optional. Annotations on the node pool. This field has the same restrictions as Kubernetes annotations. The total size of all keys and values combined is limited to 256k. Key can have 2 segments: prefix (optional) and name (required), separated by a slash (/). Prefix must be a DNS subdomain. Name must be 63 characters or less, begin and end with alphanumerics, with dashes (-), underscores (_), dots (.), and alphanumerics between. Note: This field is non-authoritative, and will only manage the annotations present in your configuration. Please refer to the field effective_annotations for all of the annotations present on the resource.
    autoscaling AwsNodePoolAutoscalingArgs
    Autoscaler configuration for this node pool.
    cluster str
    The awsCluster for the resource
    config AwsNodePoolConfigArgs
    The configuration of the node pool.
    create_time str
    Output only. The time at which this node pool was created.
    effective_annotations Mapping[str, Any]
    etag str
    Allows clients to perform consistent read-modify-writes through optimistic concurrency control. May be sent on update and delete requests to ensure the client has an up-to-date value before proceeding.
    location str
    The location for the resource
    management AwsNodePoolManagementArgs
    The Management configuration for this node pool.
    max_pods_constraint AwsNodePoolMaxPodsConstraintArgs
    The constraint on the maximum number of pods that can be run simultaneously on a node in the node pool.
    name str
    The name of this resource.
    project str
    The project for the resource
    reconciling bool
    Output only. If set, there are currently changes in flight to the node pool.
    state str
    Output only. The lifecycle state of the node pool. Possible values: STATE_UNSPECIFIED, PROVISIONING, RUNNING, RECONCILING, STOPPING, ERROR, DEGRADED
    subnet_id str
    The subnet where the node pool node run.
    uid str
    Output only. A globally unique identifier for the node pool.
    update_settings AwsNodePoolUpdateSettingsArgs
    Optional. Update settings control the speed and disruption of the node pool update.
    update_time str
    Output only. The time at which this node pool was last updated.
    version str
    The Kubernetes version to run on this node pool (e.g. 1.19.10-gke.1000). You can list all supported versions on a given Google Cloud region by calling GetAwsServerConfig.
    annotations Map<String>
    Optional. Annotations on the node pool. This field has the same restrictions as Kubernetes annotations. The total size of all keys and values combined is limited to 256k. Key can have 2 segments: prefix (optional) and name (required), separated by a slash (/). Prefix must be a DNS subdomain. Name must be 63 characters or less, begin and end with alphanumerics, with dashes (-), underscores (_), dots (.), and alphanumerics between. Note: This field is non-authoritative, and will only manage the annotations present in your configuration. Please refer to the field effective_annotations for all of the annotations present on the resource.
    autoscaling Property Map
    Autoscaler configuration for this node pool.
    cluster String
    The awsCluster for the resource
    config Property Map
    The configuration of the node pool.
    createTime String
    Output only. The time at which this node pool was created.
    effectiveAnnotations Map<Any>
    etag String
    Allows clients to perform consistent read-modify-writes through optimistic concurrency control. May be sent on update and delete requests to ensure the client has an up-to-date value before proceeding.
    location String
    The location for the resource
    management Property Map
    The Management configuration for this node pool.
    maxPodsConstraint Property Map
    The constraint on the maximum number of pods that can be run simultaneously on a node in the node pool.
    name String
    The name of this resource.
    project String
    The project for the resource
    reconciling Boolean
    Output only. If set, there are currently changes in flight to the node pool.
    state String
    Output only. The lifecycle state of the node pool. Possible values: STATE_UNSPECIFIED, PROVISIONING, RUNNING, RECONCILING, STOPPING, ERROR, DEGRADED
    subnetId String
    The subnet where the node pool node run.
    uid String
    Output only. A globally unique identifier for the node pool.
    updateSettings Property Map
    Optional. Update settings control the speed and disruption of the node pool update.
    updateTime String
    Output only. The time at which this node pool was last updated.
    version String
    The Kubernetes version to run on this node pool (e.g. 1.19.10-gke.1000). You can list all supported versions on a given Google Cloud region by calling GetAwsServerConfig.

    Supporting Types

    AwsNodePoolAutoscaling, AwsNodePoolAutoscalingArgs

    MaxNodeCount int
    Maximum number of nodes in the NodePool. Must be >= min_node_count.
    MinNodeCount int
    Minimum number of nodes in the NodePool. Must be >= 1 and <= max_node_count.
    MaxNodeCount int
    Maximum number of nodes in the NodePool. Must be >= min_node_count.
    MinNodeCount int
    Minimum number of nodes in the NodePool. Must be >= 1 and <= max_node_count.
    maxNodeCount Integer
    Maximum number of nodes in the NodePool. Must be >= min_node_count.
    minNodeCount Integer
    Minimum number of nodes in the NodePool. Must be >= 1 and <= max_node_count.
    maxNodeCount number
    Maximum number of nodes in the NodePool. Must be >= min_node_count.
    minNodeCount number
    Minimum number of nodes in the NodePool. Must be >= 1 and <= max_node_count.
    max_node_count int
    Maximum number of nodes in the NodePool. Must be >= min_node_count.
    min_node_count int
    Minimum number of nodes in the NodePool. Must be >= 1 and <= max_node_count.
    maxNodeCount Number
    Maximum number of nodes in the NodePool. Must be >= min_node_count.
    minNodeCount Number
    Minimum number of nodes in the NodePool. Must be >= 1 and <= max_node_count.

    AwsNodePoolConfig, AwsNodePoolConfigArgs

    ConfigEncryption AwsNodePoolConfigConfigEncryption
    The ARN of the AWS KMS key used to encrypt node pool configuration.
    IamInstanceProfile string
    The name of the AWS IAM role assigned to nodes in the pool.
    AutoscalingMetricsCollection AwsNodePoolConfigAutoscalingMetricsCollection
    Optional. Configuration related to CloudWatch metrics collection on the Auto Scaling group of the node pool. When unspecified, metrics collection is disabled.
    ImageType string
    The OS image type to use on node pool instances.
    InstancePlacement AwsNodePoolConfigInstancePlacement
    Details of placement information for an instance.
    InstanceType string
    Optional. The AWS instance type. When unspecified, it defaults to m5.large.
    Labels Dictionary<string, string>
    Optional. The initial labels assigned to nodes of this node pool. An object containing a list of "key": value pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
    ProxyConfig AwsNodePoolConfigProxyConfig
    Proxy configuration for outbound HTTP(S) traffic.
    RootVolume AwsNodePoolConfigRootVolume
    Optional. Template for the root volume provisioned for node pool nodes. Volumes will be provisioned in the availability zone assigned to the node pool subnet. When unspecified, it defaults to 32 GiB with the GP2 volume type.
    SecurityGroupIds List<string>
    Optional. The IDs of additional security groups to add to nodes in this pool. The manager will automatically create security groups with minimum rules needed for a functioning cluster.
    SpotConfig AwsNodePoolConfigSpotConfig
    Optional. When specified, the node pool will provision Spot instances from the set of spot_config.instance_types. This field is mutually exclusive with instance_type
    SshConfig AwsNodePoolConfigSshConfig
    Optional. The SSH configuration.
    Tags Dictionary<string, string>
    Optional. Key/value metadata to assign to each underlying AWS resource. Specify at most 50 pairs containing alphanumerics, spaces, and symbols (.+-=_:@/). Keys can be up to 127 Unicode characters. Values can be up to 255 Unicode characters.
    Taints List<AwsNodePoolConfigTaint>
    Optional. The initial taints assigned to nodes of this node pool.
    ConfigEncryption AwsNodePoolConfigConfigEncryption
    The ARN of the AWS KMS key used to encrypt node pool configuration.
    IamInstanceProfile string
    The name of the AWS IAM role assigned to nodes in the pool.
    AutoscalingMetricsCollection AwsNodePoolConfigAutoscalingMetricsCollection
    Optional. Configuration related to CloudWatch metrics collection on the Auto Scaling group of the node pool. When unspecified, metrics collection is disabled.
    ImageType string
    The OS image type to use on node pool instances.
    InstancePlacement AwsNodePoolConfigInstancePlacement
    Details of placement information for an instance.
    InstanceType string
    Optional. The AWS instance type. When unspecified, it defaults to m5.large.
    Labels map[string]string
    Optional. The initial labels assigned to nodes of this node pool. An object containing a list of "key": value pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
    ProxyConfig AwsNodePoolConfigProxyConfig
    Proxy configuration for outbound HTTP(S) traffic.
    RootVolume AwsNodePoolConfigRootVolume
    Optional. Template for the root volume provisioned for node pool nodes. Volumes will be provisioned in the availability zone assigned to the node pool subnet. When unspecified, it defaults to 32 GiB with the GP2 volume type.
    SecurityGroupIds []string
    Optional. The IDs of additional security groups to add to nodes in this pool. The manager will automatically create security groups with minimum rules needed for a functioning cluster.
    SpotConfig AwsNodePoolConfigSpotConfig
    Optional. When specified, the node pool will provision Spot instances from the set of spot_config.instance_types. This field is mutually exclusive with instance_type
    SshConfig AwsNodePoolConfigSshConfig
    Optional. The SSH configuration.
    Tags map[string]string
    Optional. Key/value metadata to assign to each underlying AWS resource. Specify at most 50 pairs containing alphanumerics, spaces, and symbols (.+-=_:@/). Keys can be up to 127 Unicode characters. Values can be up to 255 Unicode characters.
    Taints []AwsNodePoolConfigTaint
    Optional. The initial taints assigned to nodes of this node pool.
    configEncryption AwsNodePoolConfigConfigEncryption
    The ARN of the AWS KMS key used to encrypt node pool configuration.
    iamInstanceProfile String
    The name of the AWS IAM role assigned to nodes in the pool.
    autoscalingMetricsCollection AwsNodePoolConfigAutoscalingMetricsCollection
    Optional. Configuration related to CloudWatch metrics collection on the Auto Scaling group of the node pool. When unspecified, metrics collection is disabled.
    imageType String
    The OS image type to use on node pool instances.
    instancePlacement AwsNodePoolConfigInstancePlacement
    Details of placement information for an instance.
    instanceType String
    Optional. The AWS instance type. When unspecified, it defaults to m5.large.
    labels Map<String,String>
    Optional. The initial labels assigned to nodes of this node pool. An object containing a list of "key": value pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
    proxyConfig AwsNodePoolConfigProxyConfig
    Proxy configuration for outbound HTTP(S) traffic.
    rootVolume AwsNodePoolConfigRootVolume
    Optional. Template for the root volume provisioned for node pool nodes. Volumes will be provisioned in the availability zone assigned to the node pool subnet. When unspecified, it defaults to 32 GiB with the GP2 volume type.
    securityGroupIds List<String>
    Optional. The IDs of additional security groups to add to nodes in this pool. The manager will automatically create security groups with minimum rules needed for a functioning cluster.
    spotConfig AwsNodePoolConfigSpotConfig
    Optional. When specified, the node pool will provision Spot instances from the set of spot_config.instance_types. This field is mutually exclusive with instance_type
    sshConfig AwsNodePoolConfigSshConfig
    Optional. The SSH configuration.
    tags Map<String,String>
    Optional. Key/value metadata to assign to each underlying AWS resource. Specify at most 50 pairs containing alphanumerics, spaces, and symbols (.+-=_:@/). Keys can be up to 127 Unicode characters. Values can be up to 255 Unicode characters.
    taints List<AwsNodePoolConfigTaint>
    Optional. The initial taints assigned to nodes of this node pool.
    configEncryption AwsNodePoolConfigConfigEncryption
    The ARN of the AWS KMS key used to encrypt node pool configuration.
    iamInstanceProfile string
    The name of the AWS IAM role assigned to nodes in the pool.
    autoscalingMetricsCollection AwsNodePoolConfigAutoscalingMetricsCollection
    Optional. Configuration related to CloudWatch metrics collection on the Auto Scaling group of the node pool. When unspecified, metrics collection is disabled.
    imageType string
    The OS image type to use on node pool instances.
    instancePlacement AwsNodePoolConfigInstancePlacement
    Details of placement information for an instance.
    instanceType string
    Optional. The AWS instance type. When unspecified, it defaults to m5.large.
    labels {[key: string]: string}
    Optional. The initial labels assigned to nodes of this node pool. An object containing a list of "key": value pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
    proxyConfig AwsNodePoolConfigProxyConfig
    Proxy configuration for outbound HTTP(S) traffic.
    rootVolume AwsNodePoolConfigRootVolume
    Optional. Template for the root volume provisioned for node pool nodes. Volumes will be provisioned in the availability zone assigned to the node pool subnet. When unspecified, it defaults to 32 GiB with the GP2 volume type.
    securityGroupIds string[]
    Optional. The IDs of additional security groups to add to nodes in this pool. The manager will automatically create security groups with minimum rules needed for a functioning cluster.
    spotConfig AwsNodePoolConfigSpotConfig
    Optional. When specified, the node pool will provision Spot instances from the set of spot_config.instance_types. This field is mutually exclusive with instance_type
    sshConfig AwsNodePoolConfigSshConfig
    Optional. The SSH configuration.
    tags {[key: string]: string}
    Optional. Key/value metadata to assign to each underlying AWS resource. Specify at most 50 pairs containing alphanumerics, spaces, and symbols (.+-=_:@/). Keys can be up to 127 Unicode characters. Values can be up to 255 Unicode characters.
    taints AwsNodePoolConfigTaint[]
    Optional. The initial taints assigned to nodes of this node pool.
    config_encryption AwsNodePoolConfigConfigEncryption
    The ARN of the AWS KMS key used to encrypt node pool configuration.
    iam_instance_profile str
    The name of the AWS IAM role assigned to nodes in the pool.
    autoscaling_metrics_collection AwsNodePoolConfigAutoscalingMetricsCollection
    Optional. Configuration related to CloudWatch metrics collection on the Auto Scaling group of the node pool. When unspecified, metrics collection is disabled.
    image_type str
    The OS image type to use on node pool instances.
    instance_placement AwsNodePoolConfigInstancePlacement
    Details of placement information for an instance.
    instance_type str
    Optional. The AWS instance type. When unspecified, it defaults to m5.large.
    labels Mapping[str, str]
    Optional. The initial labels assigned to nodes of this node pool. An object containing a list of "key": value pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
    proxy_config AwsNodePoolConfigProxyConfig
    Proxy configuration for outbound HTTP(S) traffic.
    root_volume AwsNodePoolConfigRootVolume
    Optional. Template for the root volume provisioned for node pool nodes. Volumes will be provisioned in the availability zone assigned to the node pool subnet. When unspecified, it defaults to 32 GiB with the GP2 volume type.
    security_group_ids Sequence[str]
    Optional. The IDs of additional security groups to add to nodes in this pool. The manager will automatically create security groups with minimum rules needed for a functioning cluster.
    spot_config AwsNodePoolConfigSpotConfig
    Optional. When specified, the node pool will provision Spot instances from the set of spot_config.instance_types. This field is mutually exclusive with instance_type
    ssh_config AwsNodePoolConfigSshConfig
    Optional. The SSH configuration.
    tags Mapping[str, str]
    Optional. Key/value metadata to assign to each underlying AWS resource. Specify at most 50 pairs containing alphanumerics, spaces, and symbols (.+-=_:@/). Keys can be up to 127 Unicode characters. Values can be up to 255 Unicode characters.
    taints Sequence[AwsNodePoolConfigTaint]
    Optional. The initial taints assigned to nodes of this node pool.
    configEncryption Property Map
    The ARN of the AWS KMS key used to encrypt node pool configuration.
    iamInstanceProfile String
    The name of the AWS IAM role assigned to nodes in the pool.
    autoscalingMetricsCollection Property Map
    Optional. Configuration related to CloudWatch metrics collection on the Auto Scaling group of the node pool. When unspecified, metrics collection is disabled.
    imageType String
    The OS image type to use on node pool instances.
    instancePlacement Property Map
    Details of placement information for an instance.
    instanceType String
    Optional. The AWS instance type. When unspecified, it defaults to m5.large.
    labels Map<String>
    Optional. The initial labels assigned to nodes of this node pool. An object containing a list of "key": value pairs. Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
    proxyConfig Property Map
    Proxy configuration for outbound HTTP(S) traffic.
    rootVolume Property Map
    Optional. Template for the root volume provisioned for node pool nodes. Volumes will be provisioned in the availability zone assigned to the node pool subnet. When unspecified, it defaults to 32 GiB with the GP2 volume type.
    securityGroupIds List<String>
    Optional. The IDs of additional security groups to add to nodes in this pool. The manager will automatically create security groups with minimum rules needed for a functioning cluster.
    spotConfig Property Map
    Optional. When specified, the node pool will provision Spot instances from the set of spot_config.instance_types. This field is mutually exclusive with instance_type
    sshConfig Property Map
    Optional. The SSH configuration.
    tags Map<String>
    Optional. Key/value metadata to assign to each underlying AWS resource. Specify at most 50 pairs containing alphanumerics, spaces, and symbols (.+-=_:@/). Keys can be up to 127 Unicode characters. Values can be up to 255 Unicode characters.
    taints List<Property Map>
    Optional. The initial taints assigned to nodes of this node pool.

    AwsNodePoolConfigAutoscalingMetricsCollection, AwsNodePoolConfigAutoscalingMetricsCollectionArgs

    Granularity string
    The frequency at which EC2 Auto Scaling sends aggregated data to AWS CloudWatch. The only valid value is "1Minute".
    Metrics List<string>
    The metrics to enable. For a list of valid metrics, see https://docs.aws.amazon.com/autoscaling/ec2/APIReference/API_EnableMetricsCollection.html. If you specify granularity and don't specify any metrics, all metrics are enabled.
    Granularity string
    The frequency at which EC2 Auto Scaling sends aggregated data to AWS CloudWatch. The only valid value is "1Minute".
    Metrics []string
    The metrics to enable. For a list of valid metrics, see https://docs.aws.amazon.com/autoscaling/ec2/APIReference/API_EnableMetricsCollection.html. If you specify granularity and don't specify any metrics, all metrics are enabled.
    granularity String
    The frequency at which EC2 Auto Scaling sends aggregated data to AWS CloudWatch. The only valid value is "1Minute".
    metrics List<String>
    The metrics to enable. For a list of valid metrics, see https://docs.aws.amazon.com/autoscaling/ec2/APIReference/API_EnableMetricsCollection.html. If you specify granularity and don't specify any metrics, all metrics are enabled.
    granularity string
    The frequency at which EC2 Auto Scaling sends aggregated data to AWS CloudWatch. The only valid value is "1Minute".
    metrics string[]
    The metrics to enable. For a list of valid metrics, see https://docs.aws.amazon.com/autoscaling/ec2/APIReference/API_EnableMetricsCollection.html. If you specify granularity and don't specify any metrics, all metrics are enabled.
    granularity str
    The frequency at which EC2 Auto Scaling sends aggregated data to AWS CloudWatch. The only valid value is "1Minute".
    metrics Sequence[str]
    The metrics to enable. For a list of valid metrics, see https://docs.aws.amazon.com/autoscaling/ec2/APIReference/API_EnableMetricsCollection.html. If you specify granularity and don't specify any metrics, all metrics are enabled.
    granularity String
    The frequency at which EC2 Auto Scaling sends aggregated data to AWS CloudWatch. The only valid value is "1Minute".
    metrics List<String>
    The metrics to enable. For a list of valid metrics, see https://docs.aws.amazon.com/autoscaling/ec2/APIReference/API_EnableMetricsCollection.html. If you specify granularity and don't specify any metrics, all metrics are enabled.

    AwsNodePoolConfigConfigEncryption, AwsNodePoolConfigConfigEncryptionArgs

    KmsKeyArn string
    The ARN of the AWS KMS key used to encrypt node pool configuration.
    KmsKeyArn string
    The ARN of the AWS KMS key used to encrypt node pool configuration.
    kmsKeyArn String
    The ARN of the AWS KMS key used to encrypt node pool configuration.
    kmsKeyArn string
    The ARN of the AWS KMS key used to encrypt node pool configuration.
    kms_key_arn str
    The ARN of the AWS KMS key used to encrypt node pool configuration.
    kmsKeyArn String
    The ARN of the AWS KMS key used to encrypt node pool configuration.

    AwsNodePoolConfigInstancePlacement, AwsNodePoolConfigInstancePlacementArgs

    Tenancy string
    The tenancy for the instance. Possible values: TENANCY_UNSPECIFIED, DEFAULT, DEDICATED, HOST
    Tenancy string
    The tenancy for the instance. Possible values: TENANCY_UNSPECIFIED, DEFAULT, DEDICATED, HOST
    tenancy String
    The tenancy for the instance. Possible values: TENANCY_UNSPECIFIED, DEFAULT, DEDICATED, HOST
    tenancy string
    The tenancy for the instance. Possible values: TENANCY_UNSPECIFIED, DEFAULT, DEDICATED, HOST
    tenancy str
    The tenancy for the instance. Possible values: TENANCY_UNSPECIFIED, DEFAULT, DEDICATED, HOST
    tenancy String
    The tenancy for the instance. Possible values: TENANCY_UNSPECIFIED, DEFAULT, DEDICATED, HOST

    AwsNodePoolConfigProxyConfig, AwsNodePoolConfigProxyConfigArgs

    SecretArn string
    The ARN of the AWS Secret Manager secret that contains the HTTP(S) proxy configuration.
    SecretVersion string
    The version string of the AWS Secret Manager secret that contains the HTTP(S) proxy configuration.
    SecretArn string
    The ARN of the AWS Secret Manager secret that contains the HTTP(S) proxy configuration.
    SecretVersion string
    The version string of the AWS Secret Manager secret that contains the HTTP(S) proxy configuration.
    secretArn String
    The ARN of the AWS Secret Manager secret that contains the HTTP(S) proxy configuration.
    secretVersion String
    The version string of the AWS Secret Manager secret that contains the HTTP(S) proxy configuration.
    secretArn string
    The ARN of the AWS Secret Manager secret that contains the HTTP(S) proxy configuration.
    secretVersion string
    The version string of the AWS Secret Manager secret that contains the HTTP(S) proxy configuration.
    secret_arn str
    The ARN of the AWS Secret Manager secret that contains the HTTP(S) proxy configuration.
    secret_version str
    The version string of the AWS Secret Manager secret that contains the HTTP(S) proxy configuration.
    secretArn String
    The ARN of the AWS Secret Manager secret that contains the HTTP(S) proxy configuration.
    secretVersion String
    The version string of the AWS Secret Manager secret that contains the HTTP(S) proxy configuration.

    AwsNodePoolConfigRootVolume, AwsNodePoolConfigRootVolumeArgs

    Iops int
    Optional. The number of I/O operations per second (IOPS) to provision for GP3 volume.
    KmsKeyArn string
    Optional. The Amazon Resource Name (ARN) of the Customer Managed Key (CMK) used to encrypt AWS EBS volumes. If not specified, the default Amazon managed key associated to the AWS region where this cluster runs will be used.
    SizeGib int
    Optional. The size of the volume, in GiBs. When unspecified, a default value is provided. See the specific reference in the parent resource.
    Throughput int
    Optional. The throughput to provision for the volume, in MiB/s. Only valid if the volume type is GP3. If volume type is gp3 and throughput is not specified, the throughput will defaults to 125.
    VolumeType string
    Optional. Type of the EBS volume. When unspecified, it defaults to GP2 volume. Possible values: VOLUME_TYPE_UNSPECIFIED, GP2, GP3
    Iops int
    Optional. The number of I/O operations per second (IOPS) to provision for GP3 volume.
    KmsKeyArn string
    Optional. The Amazon Resource Name (ARN) of the Customer Managed Key (CMK) used to encrypt AWS EBS volumes. If not specified, the default Amazon managed key associated to the AWS region where this cluster runs will be used.
    SizeGib int
    Optional. The size of the volume, in GiBs. When unspecified, a default value is provided. See the specific reference in the parent resource.
    Throughput int
    Optional. The throughput to provision for the volume, in MiB/s. Only valid if the volume type is GP3. If volume type is gp3 and throughput is not specified, the throughput will defaults to 125.
    VolumeType string
    Optional. Type of the EBS volume. When unspecified, it defaults to GP2 volume. Possible values: VOLUME_TYPE_UNSPECIFIED, GP2, GP3
    iops Integer
    Optional. The number of I/O operations per second (IOPS) to provision for GP3 volume.
    kmsKeyArn String
    Optional. The Amazon Resource Name (ARN) of the Customer Managed Key (CMK) used to encrypt AWS EBS volumes. If not specified, the default Amazon managed key associated to the AWS region where this cluster runs will be used.
    sizeGib Integer
    Optional. The size of the volume, in GiBs. When unspecified, a default value is provided. See the specific reference in the parent resource.
    throughput Integer
    Optional. The throughput to provision for the volume, in MiB/s. Only valid if the volume type is GP3. If volume type is gp3 and throughput is not specified, the throughput will defaults to 125.
    volumeType String
    Optional. Type of the EBS volume. When unspecified, it defaults to GP2 volume. Possible values: VOLUME_TYPE_UNSPECIFIED, GP2, GP3
    iops number
    Optional. The number of I/O operations per second (IOPS) to provision for GP3 volume.
    kmsKeyArn string
    Optional. The Amazon Resource Name (ARN) of the Customer Managed Key (CMK) used to encrypt AWS EBS volumes. If not specified, the default Amazon managed key associated to the AWS region where this cluster runs will be used.
    sizeGib number
    Optional. The size of the volume, in GiBs. When unspecified, a default value is provided. See the specific reference in the parent resource.
    throughput number
    Optional. The throughput to provision for the volume, in MiB/s. Only valid if the volume type is GP3. If volume type is gp3 and throughput is not specified, the throughput will defaults to 125.
    volumeType string
    Optional. Type of the EBS volume. When unspecified, it defaults to GP2 volume. Possible values: VOLUME_TYPE_UNSPECIFIED, GP2, GP3
    iops int
    Optional. The number of I/O operations per second (IOPS) to provision for GP3 volume.
    kms_key_arn str
    Optional. The Amazon Resource Name (ARN) of the Customer Managed Key (CMK) used to encrypt AWS EBS volumes. If not specified, the default Amazon managed key associated to the AWS region where this cluster runs will be used.
    size_gib int
    Optional. The size of the volume, in GiBs. When unspecified, a default value is provided. See the specific reference in the parent resource.
    throughput int
    Optional. The throughput to provision for the volume, in MiB/s. Only valid if the volume type is GP3. If volume type is gp3 and throughput is not specified, the throughput will defaults to 125.
    volume_type str
    Optional. Type of the EBS volume. When unspecified, it defaults to GP2 volume. Possible values: VOLUME_TYPE_UNSPECIFIED, GP2, GP3
    iops Number
    Optional. The number of I/O operations per second (IOPS) to provision for GP3 volume.
    kmsKeyArn String
    Optional. The Amazon Resource Name (ARN) of the Customer Managed Key (CMK) used to encrypt AWS EBS volumes. If not specified, the default Amazon managed key associated to the AWS region where this cluster runs will be used.
    sizeGib Number
    Optional. The size of the volume, in GiBs. When unspecified, a default value is provided. See the specific reference in the parent resource.
    throughput Number
    Optional. The throughput to provision for the volume, in MiB/s. Only valid if the volume type is GP3. If volume type is gp3 and throughput is not specified, the throughput will defaults to 125.
    volumeType String
    Optional. Type of the EBS volume. When unspecified, it defaults to GP2 volume. Possible values: VOLUME_TYPE_UNSPECIFIED, GP2, GP3

    AwsNodePoolConfigSpotConfig, AwsNodePoolConfigSpotConfigArgs

    InstanceTypes List<string>
    List of AWS EC2 instance types for creating a spot node pool's nodes. The specified instance types must have the same number of CPUs and memory. You can use the Amazon EC2 Instance Selector tool (https://github.com/aws/amazon-ec2-instance-selector) to choose instance types with matching CPU and memory
    InstanceTypes []string
    List of AWS EC2 instance types for creating a spot node pool's nodes. The specified instance types must have the same number of CPUs and memory. You can use the Amazon EC2 Instance Selector tool (https://github.com/aws/amazon-ec2-instance-selector) to choose instance types with matching CPU and memory
    instanceTypes List<String>
    List of AWS EC2 instance types for creating a spot node pool's nodes. The specified instance types must have the same number of CPUs and memory. You can use the Amazon EC2 Instance Selector tool (https://github.com/aws/amazon-ec2-instance-selector) to choose instance types with matching CPU and memory
    instanceTypes string[]
    List of AWS EC2 instance types for creating a spot node pool's nodes. The specified instance types must have the same number of CPUs and memory. You can use the Amazon EC2 Instance Selector tool (https://github.com/aws/amazon-ec2-instance-selector) to choose instance types with matching CPU and memory
    instance_types Sequence[str]
    List of AWS EC2 instance types for creating a spot node pool's nodes. The specified instance types must have the same number of CPUs and memory. You can use the Amazon EC2 Instance Selector tool (https://github.com/aws/amazon-ec2-instance-selector) to choose instance types with matching CPU and memory
    instanceTypes List<String>
    List of AWS EC2 instance types for creating a spot node pool's nodes. The specified instance types must have the same number of CPUs and memory. You can use the Amazon EC2 Instance Selector tool (https://github.com/aws/amazon-ec2-instance-selector) to choose instance types with matching CPU and memory

    AwsNodePoolConfigSshConfig, AwsNodePoolConfigSshConfigArgs

    Ec2KeyPair string
    The name of the EC2 key pair used to login into cluster machines.
    Ec2KeyPair string
    The name of the EC2 key pair used to login into cluster machines.
    ec2KeyPair String
    The name of the EC2 key pair used to login into cluster machines.
    ec2KeyPair string
    The name of the EC2 key pair used to login into cluster machines.
    ec2_key_pair str
    The name of the EC2 key pair used to login into cluster machines.
    ec2KeyPair String
    The name of the EC2 key pair used to login into cluster machines.

    AwsNodePoolConfigTaint, AwsNodePoolConfigTaintArgs

    Effect string
    The taint effect. Possible values: EFFECT_UNSPECIFIED, NO_SCHEDULE, PREFER_NO_SCHEDULE, NO_EXECUTE
    Key string
    Key for the taint.
    Value string
    Value for the taint.
    Effect string
    The taint effect. Possible values: EFFECT_UNSPECIFIED, NO_SCHEDULE, PREFER_NO_SCHEDULE, NO_EXECUTE
    Key string
    Key for the taint.
    Value string
    Value for the taint.
    effect String
    The taint effect. Possible values: EFFECT_UNSPECIFIED, NO_SCHEDULE, PREFER_NO_SCHEDULE, NO_EXECUTE
    key String
    Key for the taint.
    value String
    Value for the taint.
    effect string
    The taint effect. Possible values: EFFECT_UNSPECIFIED, NO_SCHEDULE, PREFER_NO_SCHEDULE, NO_EXECUTE
    key string
    Key for the taint.
    value string
    Value for the taint.
    effect str
    The taint effect. Possible values: EFFECT_UNSPECIFIED, NO_SCHEDULE, PREFER_NO_SCHEDULE, NO_EXECUTE
    key str
    Key for the taint.
    value str
    Value for the taint.
    effect String
    The taint effect. Possible values: EFFECT_UNSPECIFIED, NO_SCHEDULE, PREFER_NO_SCHEDULE, NO_EXECUTE
    key String
    Key for the taint.
    value String
    Value for the taint.

    AwsNodePoolManagement, AwsNodePoolManagementArgs

    AutoRepair bool
    Optional. Whether or not the nodes will be automatically repaired.
    AutoRepair bool
    Optional. Whether or not the nodes will be automatically repaired.
    autoRepair Boolean
    Optional. Whether or not the nodes will be automatically repaired.
    autoRepair boolean
    Optional. Whether or not the nodes will be automatically repaired.
    auto_repair bool
    Optional. Whether or not the nodes will be automatically repaired.
    autoRepair Boolean
    Optional. Whether or not the nodes will be automatically repaired.

    AwsNodePoolMaxPodsConstraint, AwsNodePoolMaxPodsConstraintArgs

    MaxPodsPerNode int
    The maximum number of pods to schedule on a single node.


    MaxPodsPerNode int
    The maximum number of pods to schedule on a single node.


    maxPodsPerNode Integer
    The maximum number of pods to schedule on a single node.


    maxPodsPerNode number
    The maximum number of pods to schedule on a single node.


    max_pods_per_node int
    The maximum number of pods to schedule on a single node.


    maxPodsPerNode Number
    The maximum number of pods to schedule on a single node.


    AwsNodePoolUpdateSettings, AwsNodePoolUpdateSettingsArgs

    SurgeSettings AwsNodePoolUpdateSettingsSurgeSettings
    Optional. Settings for surge update.
    SurgeSettings AwsNodePoolUpdateSettingsSurgeSettings
    Optional. Settings for surge update.
    surgeSettings AwsNodePoolUpdateSettingsSurgeSettings
    Optional. Settings for surge update.
    surgeSettings AwsNodePoolUpdateSettingsSurgeSettings
    Optional. Settings for surge update.
    surge_settings AwsNodePoolUpdateSettingsSurgeSettings
    Optional. Settings for surge update.
    surgeSettings Property Map
    Optional. Settings for surge update.

    AwsNodePoolUpdateSettingsSurgeSettings, AwsNodePoolUpdateSettingsSurgeSettingsArgs

    MaxSurge int
    Optional. The maximum number of nodes that can be created beyond the current size of the node pool during the update process.
    MaxUnavailable int
    Optional. The maximum number of nodes that can be simultaneously unavailable during the update process. A node is considered unavailable if its status is not Ready.
    MaxSurge int
    Optional. The maximum number of nodes that can be created beyond the current size of the node pool during the update process.
    MaxUnavailable int
    Optional. The maximum number of nodes that can be simultaneously unavailable during the update process. A node is considered unavailable if its status is not Ready.
    maxSurge Integer
    Optional. The maximum number of nodes that can be created beyond the current size of the node pool during the update process.
    maxUnavailable Integer
    Optional. The maximum number of nodes that can be simultaneously unavailable during the update process. A node is considered unavailable if its status is not Ready.
    maxSurge number
    Optional. The maximum number of nodes that can be created beyond the current size of the node pool during the update process.
    maxUnavailable number
    Optional. The maximum number of nodes that can be simultaneously unavailable during the update process. A node is considered unavailable if its status is not Ready.
    max_surge int
    Optional. The maximum number of nodes that can be created beyond the current size of the node pool during the update process.
    max_unavailable int
    Optional. The maximum number of nodes that can be simultaneously unavailable during the update process. A node is considered unavailable if its status is not Ready.
    maxSurge Number
    Optional. The maximum number of nodes that can be created beyond the current size of the node pool during the update process.
    maxUnavailable Number
    Optional. The maximum number of nodes that can be simultaneously unavailable during the update process. A node is considered unavailable if its status is not Ready.

    Import

    NodePool can be imported using any of these accepted formats:

    • projects/{{project}}/locations/{{location}}/awsClusters/{{cluster}}/awsNodePools/{{name}}

    • {{project}}/{{location}}/{{cluster}}/{{name}}

    • {{location}}/{{cluster}}/{{name}}

    When using the pulumi import command, NodePool can be imported using one of the formats above. For example:

    $ pulumi import gcp:container/awsNodePool:AwsNodePool default projects/{{project}}/locations/{{location}}/awsClusters/{{cluster}}/awsNodePools/{{name}}
    
    $ pulumi import gcp:container/awsNodePool:AwsNodePool default {{project}}/{{location}}/{{cluster}}/{{name}}
    
    $ pulumi import gcp:container/awsNodePool:AwsNodePool default {{location}}/{{cluster}}/{{name}}
    

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    Google Cloud (GCP) Classic pulumi/pulumi-gcp
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the google-beta Terraform Provider.
    gcp logo
    Google Cloud Classic v7.26.0 published on Friday, Jun 7, 2024 by Pulumi