eks

package
v2.0.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Nov 9, 2023 License: Apache-2.0 Imports: 18 Imported by: 0

Documentation

Overview

Pulumi Amazon Web Services (AWS) EKS Components.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Cluster

type Cluster struct {
	pulumi.ResourceState

	// The AWS resource provider.
	AwsProvider aws.ProviderOutput `pulumi:"awsProvider"`
	// The security group for the EKS cluster.
	ClusterSecurityGroup ec2.SecurityGroupOutput `pulumi:"clusterSecurityGroup"`
	// The EKS cluster and its dependencies.
	Core CoreDataOutput `pulumi:"core"`
	// The default Node Group configuration, or undefined if `skipDefaultNodeGroup` was specified.
	DefaultNodeGroup NodeGroupDataPtrOutput `pulumi:"defaultNodeGroup"`
	// The EKS cluster.
	EksCluster eks.ClusterOutput `pulumi:"eksCluster"`
	// The ingress rule that gives node group access to cluster API server.
	EksClusterIngressRule ec2.SecurityGroupRuleOutput `pulumi:"eksClusterIngressRule"`
	// The service roles used by the EKS cluster.
	InstanceRoles iam.RoleArrayOutput `pulumi:"instanceRoles"`
	// A kubeconfig that can be used to connect to the EKS cluster.
	Kubeconfig pulumi.AnyOutput `pulumi:"kubeconfig"`
	// A kubeconfig that can be used to connect to the EKS cluster as a JSON string.
	KubeconfigJson pulumi.StringOutput `pulumi:"kubeconfigJson"`
	// The security group for the cluster's nodes.
	NodeSecurityGroup ec2.SecurityGroupOutput `pulumi:"nodeSecurityGroup"`
}

Cluster is a component that wraps the AWS and Kubernetes resources necessary to run an EKS cluster, its worker nodes, its optional StorageClasses, and an optional deployment of the Kubernetes Dashboard.

func NewCluster

func NewCluster(ctx *pulumi.Context,
	name string, args *ClusterArgs, opts ...pulumi.ResourceOption) (*Cluster, error)

NewCluster registers a new resource with the given unique name, arguments, and options.

func (*Cluster) ElementType

func (*Cluster) ElementType() reflect.Type

func (*Cluster) GetKubeconfig

func (r *Cluster) GetKubeconfig(ctx *pulumi.Context, args *ClusterGetKubeconfigArgs) (pulumi.StringOutput, error)

Generate a kubeconfig for cluster authentication that does not use the default AWS credential provider chain, and instead is scoped to the supported options in `KubeconfigOptions`.

The kubeconfig generated is automatically stringified for ease of use with the pulumi/kubernetes provider.

See for more details: - https://docs.aws.amazon.com/eks/latest/userguide/create-kubeconfig.html - https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-role.html - https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-profiles.html

func (*Cluster) ToClusterOutput

func (i *Cluster) ToClusterOutput() ClusterOutput

func (*Cluster) ToClusterOutputWithContext

func (i *Cluster) ToClusterOutputWithContext(ctx context.Context) ClusterOutput

func (*Cluster) ToOutput

func (i *Cluster) ToOutput(ctx context.Context) pulumix.Output[*Cluster]

type ClusterArgs

type ClusterArgs struct {
	// The security group to use for the cluster API endpoint. If not provided, a new security group will be created with full internet egress and ingress from node groups.
	ClusterSecurityGroup ec2.SecurityGroupInput
	// The tags to apply to the cluster security group.
	ClusterSecurityGroupTags pulumi.StringMapInput
	// The tags to apply to the EKS cluster.
	ClusterTags pulumi.StringMapInput
	// Indicates whether an IAM OIDC Provider is created for the EKS cluster.
	//
	// The OIDC provider is used in the cluster in combination with k8s Service Account annotations to provide IAM roles at the k8s Pod level.
	//
	// See for more details:
	//  - https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_oidc_verify-thumbprint.html
	//  - https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html
	//  - https://aws.amazon.com/blogs/opensource/introducing-fine-grained-iam-roles-service-accounts/
	//  - https://www.pulumi.com/docs/reference/pkg/nodejs/pulumi/aws/eks/#enabling-iam-roles-for-service-accounts
	CreateOidcProvider pulumi.BoolPtrInput
	// The IAM Role Provider used to create & authenticate against the EKS cluster. This role is given `[system:masters]` permission in K8S, See: https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html
	CreationRoleProvider *CreationRoleProviderArgs
	// List of addons to remove upon creation. Any addon listed will be "adopted" and then removed. This allows for the creation of a baremetal cluster where no addon is deployed and direct management of addons via Pulumi Kubernetes resources. Valid entries are kube-proxy, coredns and vpc-cni. Only works on first creation of a cluster.
	DefaultAddonsToRemove pulumi.StringArrayInput
	// The number of worker nodes that should be running in the cluster. Defaults to 2.
	DesiredCapacity pulumi.IntPtrInput
	// Enable EKS control plane logging. This sends logs to cloudwatch. Possible list of values are: ["api", "audit", "authenticator", "controllerManager", "scheduler"]. By default it is off.
	EnabledClusterLogTypes pulumi.StringArrayInput
	// KMS Key ARN to use with the encryption configuration for the cluster.
	//
	// Only available on Kubernetes 1.13+ clusters created after March 6, 2020.
	// See for more details:
	// - https://aws.amazon.com/about-aws/whats-new/2020/03/amazon-eks-adds-envelope-encryption-for-secrets-with-aws-kms/
	EncryptionConfigKeyArn pulumi.StringPtrInput
	// Indicates whether or not the Amazon EKS private API server endpoint is enabled. Default is `false`.
	EndpointPrivateAccess pulumi.BoolPtrInput
	// Indicates whether or not the Amazon EKS public API server endpoint is enabled. Default is `true`.
	EndpointPublicAccess pulumi.BoolPtrInput
	// Add support for launching pods in Fargate. Defaults to launching pods in the `default` namespace.  If specified, the default node group is skipped as though `skipDefaultNodeGroup: true` had been passed.
	Fargate pulumi.Input
	// Use the latest recommended EKS Optimized Linux AMI with GPU support for the worker nodes from the AWS Systems Manager Parameter Store.
	//
	// Defaults to false.
	//
	// Note: `gpu` and `nodeAmiId` are mutually exclusive.
	//
	// See for more details:
	// - https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html
	// - https://docs.aws.amazon.com/eks/latest/userguide/retrieve-ami-id.html
	Gpu pulumi.BoolPtrInput
	// The default IAM InstanceProfile to use on the Worker NodeGroups, if one is not already set in the NodeGroup.
	InstanceProfileName pulumi.StringPtrInput
	// This enables the simple case of only registering a *single* IAM instance role with the cluster, that is required to be shared by *all* node groups in their instance profiles.
	//
	// Note: options `instanceRole` and `instanceRoles` are mutually exclusive.
	InstanceRole iam.RoleInput
	// This enables the advanced case of registering *many* IAM instance roles with the cluster for per node group IAM, instead of the simpler, shared case of `instanceRole`.
	//
	// Note: options `instanceRole` and `instanceRoles` are mutually exclusive.
	InstanceRoles iam.RoleArrayInput
	// The instance type to use for the cluster's nodes. Defaults to "t2.medium".
	InstanceType pulumi.StringPtrInput
	// The CIDR block to assign Kubernetes service IP addresses from. If you don't
	// specify a block, Kubernetes assigns addresses from either the 10.100.0.0/16 or
	// 172.20.0.0/16 CIDR blocks. We recommend that you specify a block that does not overlap
	// with resources in other networks that are peered or connected to your VPC. You can only specify
	// a custom CIDR block when you create a cluster, changing this value will force a new cluster to be created.
	//
	// The block must meet the following requirements:
	// - Within one of the following private IP address blocks: 10.0.0.0/8, 172.16.0.0.0/12, or 192.168.0.0/16.
	// - Doesn't overlap with any CIDR block assigned to the VPC that you selected for VPC.
	// - Between /24 and /12.
	KubernetesServiceIpAddressRange pulumi.StringPtrInput
	// The maximum number of worker nodes running in the cluster. Defaults to 2.
	MaxSize pulumi.IntPtrInput
	// The minimum number of worker nodes running in the cluster. Defaults to 1.
	MinSize pulumi.IntPtrInput
	// The cluster's physical resource name.
	//
	// If not specified, the default is to use auto-naming for the cluster's name, resulting in a physical name with the format `${name}-eksCluster-0123abcd`.
	//
	// See for more details: https://www.pulumi.com/docs/intro/concepts/programming-model/#autonaming
	Name pulumi.StringPtrInput
	// The AMI ID to use for the worker nodes.
	//
	// Defaults to the latest recommended EKS Optimized Linux AMI from the AWS Systems Manager Parameter Store.
	//
	// Note: `nodeAmiId` and `gpu` are mutually exclusive.
	//
	// See for more details:
	// - https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html.
	NodeAmiId pulumi.StringPtrInput
	// Whether or not to auto-assign the EKS worker nodes public IP addresses. If this toggle is set to true, the EKS workers will be auto-assigned public IPs. If false, they will not be auto-assigned public IPs.
	NodeAssociatePublicIpAddress *bool
	// The common configuration settings for NodeGroups.
	NodeGroupOptions *ClusterNodeGroupOptionsArgs
	// Public key material for SSH access to worker nodes. See allowed formats at:
	// https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html
	// If not provided, no SSH access is enabled on VMs.
	NodePublicKey pulumi.StringPtrInput
	// Encrypt the root block device of the nodes in the node group.
	NodeRootVolumeEncrypted pulumi.BoolPtrInput
	// The size in GiB of a cluster node's root volume. Defaults to 20.
	NodeRootVolumeSize pulumi.IntPtrInput
	// The tags to apply to the default `nodeSecurityGroup` created by the cluster.
	//
	// Note: The `nodeSecurityGroupTags` option and the node group option `nodeSecurityGroup` are mutually exclusive.
	NodeSecurityGroupTags pulumi.StringMapInput
	// The subnets to use for worker nodes. Defaults to the value of subnetIds.
	NodeSubnetIds pulumi.StringArrayInput
	// Extra code to run on node startup. This code will run after the AWS EKS bootstrapping code and before the node signals its readiness to the managing CloudFormation stack. This code must be a typical user data script: critically it must begin with an interpreter directive (i.e. a `#!`).
	NodeUserData pulumi.StringPtrInput
	// The set of private subnets to use for the worker node groups on the EKS cluster. These subnets are automatically tagged by EKS for Kubernetes purposes.
	//
	// If `vpcId` is not set, the cluster will use the AWS account's default VPC subnets.
	//
	// Worker network architecture options:
	//  - Private-only: Only set `privateSubnetIds`.
	//    - Default workers to run in a private subnet. In this setting, Kubernetes cannot create public, internet-facing load balancers for your pods.
	//  - Public-only: Only set `publicSubnetIds`.
	//    - Default workers to run in a public subnet.
	//  - Mixed (recommended): Set both `privateSubnetIds` and `publicSubnetIds`.
	//    - Default all worker nodes to run in private subnets, and use the public subnets for internet-facing load balancers.
	//
	// See for more details: https://docs.aws.amazon.com/eks/latest/userguide/network_reqs.html.Note: The use of `subnetIds`, along with `publicSubnetIds` and/or `privateSubnetIds` is mutually exclusive. The use of `publicSubnetIds` and `privateSubnetIds` is encouraged.
	//
	// Also consider setting `nodeAssociatePublicIpAddress: false` for fully private workers.
	PrivateSubnetIds pulumi.StringArrayInput
	// The AWS provider credential options to scope the cluster's kubeconfig authentication when using a non-default credential chain.
	//
	// This is required for certain auth scenarios. For example:
	// - Creating and using a new AWS provider instance, or
	// - Setting the AWS_PROFILE environment variable, or
	// - Using a named profile configured on the AWS provider via:
	//   `pulumi config set aws:profile <profileName>`
	//
	// See for more details:
	// - https://www.pulumi.com/docs/reference/pkg/nodejs/pulumi/aws/#Provider
	// - https://www.pulumi.com/docs/intro/cloud-providers/aws/setup/
	// - https://www.pulumi.com/docs/intro/cloud-providers/aws/#configuration
	// - https://docs.aws.amazon.com/eks/latest/userguide/create-kubeconfig.html
	ProviderCredentialOpts KubeconfigOptionsPtrInput
	// The HTTP(S) proxy to use within a proxied environment.
	//
	//  The proxy is used during cluster creation, and OIDC configuration.
	//
	// This is an alternative option to setting the proxy environment variables: HTTP(S)_PROXY and/or http(s)_proxy.
	//
	// This option is required iff the proxy environment variables are not set.
	//
	// Format:      <protocol>://<host>:<port>
	// Auth Format: <protocol>://<username>:<password>@<host>:<port>
	//
	// Ex:
	//   - "http://proxy.example.com:3128"
	//   - "https://proxy.example.com"
	//   - "http://username:password@proxy.example.com:3128"
	Proxy *string
	// Indicates which CIDR blocks can access the Amazon EKS public API server endpoint.
	PublicAccessCidrs pulumi.StringArrayInput
	// The set of public subnets to use for the worker node groups on the EKS cluster. These subnets are automatically tagged by EKS for Kubernetes purposes.
	//
	// If `vpcId` is not set, the cluster will use the AWS account's default VPC subnets.
	//
	// Worker network architecture options:
	//  - Private-only: Only set `privateSubnetIds`.
	//    - Default workers to run in a private subnet. In this setting, Kubernetes cannot create public, internet-facing load balancers for your pods.
	//  - Public-only: Only set `publicSubnetIds`.
	//    - Default workers to run in a public subnet.
	//  - Mixed (recommended): Set both `privateSubnetIds` and `publicSubnetIds`.
	//    - Default all worker nodes to run in private subnets, and use the public subnets for internet-facing load balancers.
	//
	// See for more details: https://docs.aws.amazon.com/eks/latest/userguide/network_reqs.html.Note: The use of `subnetIds`, along with `publicSubnetIds` and/or `privateSubnetIds` is mutually exclusive. The use of `publicSubnetIds` and `privateSubnetIds` is encouraged.
	PublicSubnetIds pulumi.StringArrayInput
	// Optional mappings from AWS IAM roles to Kubernetes users and groups.
	RoleMappings RoleMappingArrayInput
	// IAM Service Role for EKS to use to manage the cluster.
	ServiceRole iam.RoleInput
	// If this toggle is set to true, the EKS cluster will be created without node group attached. Defaults to false, unless `fargate` input is provided.
	SkipDefaultNodeGroup *bool
	// An optional set of StorageClasses to enable for the cluster. If this is a single volume type rather than a map, a single StorageClass will be created for that volume type.
	//
	// Note: As of Kubernetes v1.11+ on EKS, a default `gp2` storage class will always be created automatically for the cluster by the EKS service. See https://docs.aws.amazon.com/eks/latest/userguide/storage-classes.html
	StorageClasses interface{}
	// The set of all subnets, public and private, to use for the worker node groups on the EKS cluster. These subnets are automatically tagged by EKS for Kubernetes purposes.
	//
	// If `vpcId` is not set, the cluster will use the AWS account's default VPC subnets.
	//
	// If the list of subnets includes both public and private subnets, the worker nodes will only be attached to the private subnets, and the public subnets will be used for internet-facing load balancers.
	//
	// See for more details: https://docs.aws.amazon.com/eks/latest/userguide/network_reqs.html.
	//
	// Note: The use of `subnetIds`, along with `publicSubnetIds` and/or `privateSubnetIds` is mutually exclusive. The use of `publicSubnetIds` and `privateSubnetIds` is encouraged.
	SubnetIds pulumi.StringArrayInput
	// Key-value mapping of tags that are automatically applied to all AWS resources directly under management with this cluster, which support tagging.
	Tags pulumi.StringMapInput
	// Use the default VPC CNI instead of creating a custom one. Should not be used in conjunction with `vpcCniOptions`.
	UseDefaultVpcCni *bool
	// Optional mappings from AWS IAM users to Kubernetes users and groups.
	UserMappings UserMappingArrayInput
	// Desired Kubernetes master / control plane version. If you do not specify a value, the latest available version is used.
	Version pulumi.StringPtrInput
	// The configuration of the Amazon VPC CNI plugin for this instance. Defaults are described in the documentation for the VpcCniOptions type.
	VpcCniOptions *VpcCniOptionsArgs
	// The VPC in which to create the cluster and its worker nodes. If unset, the cluster will be created in the default VPC.
	VpcId pulumi.StringPtrInput
}

The set of arguments for constructing a Cluster resource.

func (ClusterArgs) ElementType

func (ClusterArgs) ElementType() reflect.Type

type ClusterArray

type ClusterArray []ClusterInput

func (ClusterArray) ElementType

func (ClusterArray) ElementType() reflect.Type

func (ClusterArray) ToClusterArrayOutput

func (i ClusterArray) ToClusterArrayOutput() ClusterArrayOutput

func (ClusterArray) ToClusterArrayOutputWithContext

func (i ClusterArray) ToClusterArrayOutputWithContext(ctx context.Context) ClusterArrayOutput

func (ClusterArray) ToOutput

func (i ClusterArray) ToOutput(ctx context.Context) pulumix.Output[[]*Cluster]

type ClusterArrayInput

type ClusterArrayInput interface {
	pulumi.Input

	ToClusterArrayOutput() ClusterArrayOutput
	ToClusterArrayOutputWithContext(context.Context) ClusterArrayOutput
}

ClusterArrayInput is an input type that accepts ClusterArray and ClusterArrayOutput values. You can construct a concrete instance of `ClusterArrayInput` via:

ClusterArray{ ClusterArgs{...} }

type ClusterArrayOutput

type ClusterArrayOutput struct{ *pulumi.OutputState }

func (ClusterArrayOutput) ElementType

func (ClusterArrayOutput) ElementType() reflect.Type

func (ClusterArrayOutput) Index

func (ClusterArrayOutput) ToClusterArrayOutput

func (o ClusterArrayOutput) ToClusterArrayOutput() ClusterArrayOutput

func (ClusterArrayOutput) ToClusterArrayOutputWithContext

func (o ClusterArrayOutput) ToClusterArrayOutputWithContext(ctx context.Context) ClusterArrayOutput

func (ClusterArrayOutput) ToOutput

type ClusterCreationRoleProvider

type ClusterCreationRoleProvider struct {
	pulumi.ResourceState

	Role iam.RoleOutput `pulumi:"role"`
}

ClusterCreationRoleProvider is a component that wraps creating a role provider that can be passed to the `Cluster`'s `creationRoleProvider`. This can be used to provide a specific role to use for the creation of the EKS cluster different from the role being used to run the Pulumi deployment.

func NewClusterCreationRoleProvider

func NewClusterCreationRoleProvider(ctx *pulumi.Context,
	name string, args *ClusterCreationRoleProviderArgs, opts ...pulumi.ResourceOption) (*ClusterCreationRoleProvider, error)

NewClusterCreationRoleProvider registers a new resource with the given unique name, arguments, and options.

func (*ClusterCreationRoleProvider) ElementType

func (*ClusterCreationRoleProvider) ElementType() reflect.Type

func (*ClusterCreationRoleProvider) ToClusterCreationRoleProviderOutput

func (i *ClusterCreationRoleProvider) ToClusterCreationRoleProviderOutput() ClusterCreationRoleProviderOutput

func (*ClusterCreationRoleProvider) ToClusterCreationRoleProviderOutputWithContext

func (i *ClusterCreationRoleProvider) ToClusterCreationRoleProviderOutputWithContext(ctx context.Context) ClusterCreationRoleProviderOutput

func (*ClusterCreationRoleProvider) ToOutput

type ClusterCreationRoleProviderArgs

type ClusterCreationRoleProviderArgs struct {
	Profile pulumi.StringPtrInput
	Region  pulumi.StringPtrInput
}

The set of arguments for constructing a ClusterCreationRoleProvider resource.

func (ClusterCreationRoleProviderArgs) ElementType

type ClusterCreationRoleProviderArray

type ClusterCreationRoleProviderArray []ClusterCreationRoleProviderInput

func (ClusterCreationRoleProviderArray) ElementType

func (ClusterCreationRoleProviderArray) ToClusterCreationRoleProviderArrayOutput

func (i ClusterCreationRoleProviderArray) ToClusterCreationRoleProviderArrayOutput() ClusterCreationRoleProviderArrayOutput

func (ClusterCreationRoleProviderArray) ToClusterCreationRoleProviderArrayOutputWithContext

func (i ClusterCreationRoleProviderArray) ToClusterCreationRoleProviderArrayOutputWithContext(ctx context.Context) ClusterCreationRoleProviderArrayOutput

func (ClusterCreationRoleProviderArray) ToOutput

type ClusterCreationRoleProviderArrayInput

type ClusterCreationRoleProviderArrayInput interface {
	pulumi.Input

	ToClusterCreationRoleProviderArrayOutput() ClusterCreationRoleProviderArrayOutput
	ToClusterCreationRoleProviderArrayOutputWithContext(context.Context) ClusterCreationRoleProviderArrayOutput
}

ClusterCreationRoleProviderArrayInput is an input type that accepts ClusterCreationRoleProviderArray and ClusterCreationRoleProviderArrayOutput values. You can construct a concrete instance of `ClusterCreationRoleProviderArrayInput` via:

ClusterCreationRoleProviderArray{ ClusterCreationRoleProviderArgs{...} }

type ClusterCreationRoleProviderArrayOutput

type ClusterCreationRoleProviderArrayOutput struct{ *pulumi.OutputState }

func (ClusterCreationRoleProviderArrayOutput) ElementType

func (ClusterCreationRoleProviderArrayOutput) Index

func (ClusterCreationRoleProviderArrayOutput) ToClusterCreationRoleProviderArrayOutput

func (o ClusterCreationRoleProviderArrayOutput) ToClusterCreationRoleProviderArrayOutput() ClusterCreationRoleProviderArrayOutput

func (ClusterCreationRoleProviderArrayOutput) ToClusterCreationRoleProviderArrayOutputWithContext

func (o ClusterCreationRoleProviderArrayOutput) ToClusterCreationRoleProviderArrayOutputWithContext(ctx context.Context) ClusterCreationRoleProviderArrayOutput

func (ClusterCreationRoleProviderArrayOutput) ToOutput

type ClusterCreationRoleProviderInput

type ClusterCreationRoleProviderInput interface {
	pulumi.Input

	ToClusterCreationRoleProviderOutput() ClusterCreationRoleProviderOutput
	ToClusterCreationRoleProviderOutputWithContext(ctx context.Context) ClusterCreationRoleProviderOutput
}

type ClusterCreationRoleProviderMap

type ClusterCreationRoleProviderMap map[string]ClusterCreationRoleProviderInput

func (ClusterCreationRoleProviderMap) ElementType

func (ClusterCreationRoleProviderMap) ToClusterCreationRoleProviderMapOutput

func (i ClusterCreationRoleProviderMap) ToClusterCreationRoleProviderMapOutput() ClusterCreationRoleProviderMapOutput

func (ClusterCreationRoleProviderMap) ToClusterCreationRoleProviderMapOutputWithContext

func (i ClusterCreationRoleProviderMap) ToClusterCreationRoleProviderMapOutputWithContext(ctx context.Context) ClusterCreationRoleProviderMapOutput

func (ClusterCreationRoleProviderMap) ToOutput

type ClusterCreationRoleProviderMapInput

type ClusterCreationRoleProviderMapInput interface {
	pulumi.Input

	ToClusterCreationRoleProviderMapOutput() ClusterCreationRoleProviderMapOutput
	ToClusterCreationRoleProviderMapOutputWithContext(context.Context) ClusterCreationRoleProviderMapOutput
}

ClusterCreationRoleProviderMapInput is an input type that accepts ClusterCreationRoleProviderMap and ClusterCreationRoleProviderMapOutput values. You can construct a concrete instance of `ClusterCreationRoleProviderMapInput` via:

ClusterCreationRoleProviderMap{ "key": ClusterCreationRoleProviderArgs{...} }

type ClusterCreationRoleProviderMapOutput

type ClusterCreationRoleProviderMapOutput struct{ *pulumi.OutputState }

func (ClusterCreationRoleProviderMapOutput) ElementType

func (ClusterCreationRoleProviderMapOutput) MapIndex

func (ClusterCreationRoleProviderMapOutput) ToClusterCreationRoleProviderMapOutput

func (o ClusterCreationRoleProviderMapOutput) ToClusterCreationRoleProviderMapOutput() ClusterCreationRoleProviderMapOutput

func (ClusterCreationRoleProviderMapOutput) ToClusterCreationRoleProviderMapOutputWithContext

func (o ClusterCreationRoleProviderMapOutput) ToClusterCreationRoleProviderMapOutputWithContext(ctx context.Context) ClusterCreationRoleProviderMapOutput

func (ClusterCreationRoleProviderMapOutput) ToOutput

type ClusterCreationRoleProviderOutput

type ClusterCreationRoleProviderOutput struct{ *pulumi.OutputState }

func (ClusterCreationRoleProviderOutput) ElementType

func (ClusterCreationRoleProviderOutput) Role

func (ClusterCreationRoleProviderOutput) ToClusterCreationRoleProviderOutput

func (o ClusterCreationRoleProviderOutput) ToClusterCreationRoleProviderOutput() ClusterCreationRoleProviderOutput

func (ClusterCreationRoleProviderOutput) ToClusterCreationRoleProviderOutputWithContext

func (o ClusterCreationRoleProviderOutput) ToClusterCreationRoleProviderOutputWithContext(ctx context.Context) ClusterCreationRoleProviderOutput

func (ClusterCreationRoleProviderOutput) ToOutput

type ClusterGetKubeconfigArgs

type ClusterGetKubeconfigArgs struct {
	// AWS credential profile name to always use instead of the default AWS credential provider chain.
	//
	// The profile is passed to kubeconfig as an authentication environment setting.
	ProfileName pulumi.StringPtrInput
	// Role ARN to assume instead of the default AWS credential provider chain.
	//
	// The role is passed to kubeconfig as an authentication exec argument.
	RoleArn pulumi.StringPtrInput
}

The set of arguments for the GetKubeconfig method of the Cluster resource.

func (ClusterGetKubeconfigArgs) ElementType

func (ClusterGetKubeconfigArgs) ElementType() reflect.Type

type ClusterInput

type ClusterInput interface {
	pulumi.Input

	ToClusterOutput() ClusterOutput
	ToClusterOutputWithContext(ctx context.Context) ClusterOutput
}

type ClusterMap

type ClusterMap map[string]ClusterInput

func (ClusterMap) ElementType

func (ClusterMap) ElementType() reflect.Type

func (ClusterMap) ToClusterMapOutput

func (i ClusterMap) ToClusterMapOutput() ClusterMapOutput

func (ClusterMap) ToClusterMapOutputWithContext

func (i ClusterMap) ToClusterMapOutputWithContext(ctx context.Context) ClusterMapOutput

func (ClusterMap) ToOutput

func (i ClusterMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*Cluster]

type ClusterMapInput

type ClusterMapInput interface {
	pulumi.Input

	ToClusterMapOutput() ClusterMapOutput
	ToClusterMapOutputWithContext(context.Context) ClusterMapOutput
}

ClusterMapInput is an input type that accepts ClusterMap and ClusterMapOutput values. You can construct a concrete instance of `ClusterMapInput` via:

ClusterMap{ "key": ClusterArgs{...} }

type ClusterMapOutput

type ClusterMapOutput struct{ *pulumi.OutputState }

func (ClusterMapOutput) ElementType

func (ClusterMapOutput) ElementType() reflect.Type

func (ClusterMapOutput) MapIndex

func (ClusterMapOutput) ToClusterMapOutput

func (o ClusterMapOutput) ToClusterMapOutput() ClusterMapOutput

func (ClusterMapOutput) ToClusterMapOutputWithContext

func (o ClusterMapOutput) ToClusterMapOutputWithContext(ctx context.Context) ClusterMapOutput

func (ClusterMapOutput) ToOutput

type ClusterNodeGroupOptions

type ClusterNodeGroupOptions struct {
	// The AMI ID to use for the worker nodes.
	//
	// Defaults to the latest recommended EKS Optimized Linux AMI from the AWS Systems Manager Parameter Store.
	//
	// Note: `amiId` and `gpu` are mutually exclusive.
	//
	// See for more details:
	// - https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html.
	AmiId *string `pulumi:"amiId"`
	// The AMI Type to use for the worker nodes.
	//
	// Only applicable when setting an AMI ID that is of type `arm64`.
	//
	// Note: `amiType` and `gpu` are mutually exclusive.
	AmiType *string `pulumi:"amiType"`
	// The tags to apply to the NodeGroup's AutoScalingGroup in the CloudFormation Stack.
	//
	// Per AWS, all stack-level tags, including automatically created tags, and the `cloudFormationTags` option are propagated to resources that AWS CloudFormation supports, including the AutoScalingGroup. See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-resource-tags.html
	//
	// Note: Given the inheritance of auto-generated CF tags and `cloudFormationTags`, you should either supply the tag in `autoScalingGroupTags` or `cloudFormationTags`, but not both.
	AutoScalingGroupTags map[string]string `pulumi:"autoScalingGroupTags"`
	// Additional args to pass directly to `/etc/eks/bootstrap.sh`. For details on available options, see: https://github.com/awslabs/amazon-eks-ami/blob/master/files/bootstrap.sh. Note that the `--apiserver-endpoint`, `--b64-cluster-ca` and `--kubelet-extra-args` flags are included automatically based on other configuration parameters.
	BootstrapExtraArgs *string `pulumi:"bootstrapExtraArgs"`
	// The tags to apply to the CloudFormation Stack of the Worker NodeGroup.
	//
	// Note: Given the inheritance of auto-generated CF tags and `cloudFormationTags`, you should either supply the tag in `autoScalingGroupTags` or `cloudFormationTags`, but not both.
	CloudFormationTags map[string]string `pulumi:"cloudFormationTags"`
	// The ingress rule that gives node group access.
	ClusterIngressRule *ec2.SecurityGroupRule `pulumi:"clusterIngressRule"`
	// The number of worker nodes that should be running in the cluster. Defaults to 2.
	DesiredCapacity *int `pulumi:"desiredCapacity"`
	// Encrypt the root block device of the nodes in the node group.
	EncryptRootBlockDevice *bool `pulumi:"encryptRootBlockDevice"`
	// Extra security groups to attach on all nodes in this worker node group.
	//
	// This additional set of security groups captures any user application rules that will be needed for the nodes.
	ExtraNodeSecurityGroups []*ec2.SecurityGroup `pulumi:"extraNodeSecurityGroups"`
	// Use the latest recommended EKS Optimized Linux AMI with GPU support for the worker nodes from the AWS Systems Manager Parameter Store.
	//
	// Defaults to false.
	//
	// Note: `gpu` and `amiId` are mutually exclusive.
	//
	// See for more details:
	// - https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html
	// - https://docs.aws.amazon.com/eks/latest/userguide/retrieve-ami-id.html
	Gpu *bool `pulumi:"gpu"`
	// The ingress rule that gives node group access.
	InstanceProfile *iam.InstanceProfile `pulumi:"instanceProfile"`
	// The instance type to use for the cluster's nodes. Defaults to "t2.medium".
	InstanceType *string `pulumi:"instanceType"`
	// Name of the key pair to use for SSH access to worker nodes.
	KeyName *string `pulumi:"keyName"`
	// Extra args to pass to the Kubelet. Corresponds to the options passed in the `--kubeletExtraArgs` flag to `/etc/eks/bootstrap.sh`. For example, '--port=10251 --address=0.0.0.0'. Note that the `labels` and `taints` properties will be applied to this list (using `--node-labels` and `--register-with-taints` respectively) after to the explicit `kubeletExtraArgs`.
	KubeletExtraArgs *string `pulumi:"kubeletExtraArgs"`
	// Custom k8s node labels to be attached to each worker node. Adds the given key/value pairs to the `--node-labels` kubelet argument.
	Labels map[string]string `pulumi:"labels"`
	// The maximum number of worker nodes running in the cluster. Defaults to 2.
	MaxSize *int `pulumi:"maxSize"`
	// The minimum number of worker nodes running in the cluster. Defaults to 1.
	MinSize *int `pulumi:"minSize"`
	// Whether or not to auto-assign public IP addresses on the EKS worker nodes. If this toggle is set to true, the EKS workers will be auto-assigned public IPs. If false, they will not be auto-assigned public IPs.
	NodeAssociatePublicIpAddress *bool `pulumi:"nodeAssociatePublicIpAddress"`
	// Public key material for SSH access to worker nodes. See allowed formats at:
	// https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html
	// If not provided, no SSH access is enabled on VMs.
	NodePublicKey *string `pulumi:"nodePublicKey"`
	// The size in GiB of a cluster node's root volume. Defaults to 20.
	NodeRootVolumeSize *int `pulumi:"nodeRootVolumeSize"`
	// The security group for the worker node group to communicate with the cluster.
	//
	// This security group requires specific inbound and outbound rules.
	//
	// See for more details:
	// https://docs.aws.amazon.com/eks/latest/userguide/sec-group-reqs.html
	//
	// Note: The `nodeSecurityGroup` option and the cluster option`nodeSecurityGroupTags` are mutually exclusive.
	NodeSecurityGroup *ec2.SecurityGroup `pulumi:"nodeSecurityGroup"`
	// The set of subnets to override and use for the worker node group.
	//
	// Setting this option overrides which subnets to use for the worker node group, regardless if the cluster's `subnetIds` is set, or if `publicSubnetIds` and/or `privateSubnetIds` were set.
	NodeSubnetIds []string `pulumi:"nodeSubnetIds"`
	// Extra code to run on node startup. This code will run after the AWS EKS bootstrapping code and before the node signals its readiness to the managing CloudFormation stack. This code must be a typical user data script: critically it must begin with an interpreter directive (i.e. a `#!`).
	NodeUserData *string `pulumi:"nodeUserData"`
	// User specified code to run on node startup. This code is expected to handle the full AWS EKS bootstrapping code and signal node readiness to the managing CloudFormation stack. This code must be a complete and executable user data script in bash (Linux) or powershell (Windows).
	//
	// See for more details: https://docs.aws.amazon.com/eks/latest/userguide/worker.html
	NodeUserDataOverride *string `pulumi:"nodeUserDataOverride"`
	// Bidding price for spot instance. If set, only spot instances will be added as worker node.
	SpotPrice *string `pulumi:"spotPrice"`
	// Custom k8s node taints to be attached to each worker node. Adds the given taints to the `--register-with-taints` kubelet argument
	Taints map[string]Taint `pulumi:"taints"`
	// Desired Kubernetes master / control plane version. If you do not specify a value, the latest available version is used.
	Version *string `pulumi:"version"`
}

Describes the configuration options accepted by a cluster to create its own node groups.

type ClusterNodeGroupOptionsArgs

type ClusterNodeGroupOptionsArgs struct {
	// The AMI ID to use for the worker nodes.
	//
	// Defaults to the latest recommended EKS Optimized Linux AMI from the AWS Systems Manager Parameter Store.
	//
	// Note: `amiId` and `gpu` are mutually exclusive.
	//
	// See for more details:
	// - https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html.
	AmiId pulumi.StringPtrInput `pulumi:"amiId"`
	// The AMI Type to use for the worker nodes.
	//
	// Only applicable when setting an AMI ID that is of type `arm64`.
	//
	// Note: `amiType` and `gpu` are mutually exclusive.
	AmiType pulumi.StringPtrInput `pulumi:"amiType"`
	// The tags to apply to the NodeGroup's AutoScalingGroup in the CloudFormation Stack.
	//
	// Per AWS, all stack-level tags, including automatically created tags, and the `cloudFormationTags` option are propagated to resources that AWS CloudFormation supports, including the AutoScalingGroup. See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-resource-tags.html
	//
	// Note: Given the inheritance of auto-generated CF tags and `cloudFormationTags`, you should either supply the tag in `autoScalingGroupTags` or `cloudFormationTags`, but not both.
	AutoScalingGroupTags pulumi.StringMapInput `pulumi:"autoScalingGroupTags"`
	// Additional args to pass directly to `/etc/eks/bootstrap.sh`. For details on available options, see: https://github.com/awslabs/amazon-eks-ami/blob/master/files/bootstrap.sh. Note that the `--apiserver-endpoint`, `--b64-cluster-ca` and `--kubelet-extra-args` flags are included automatically based on other configuration parameters.
	BootstrapExtraArgs *string `pulumi:"bootstrapExtraArgs"`
	// The tags to apply to the CloudFormation Stack of the Worker NodeGroup.
	//
	// Note: Given the inheritance of auto-generated CF tags and `cloudFormationTags`, you should either supply the tag in `autoScalingGroupTags` or `cloudFormationTags`, but not both.
	CloudFormationTags pulumi.StringMapInput `pulumi:"cloudFormationTags"`
	// The ingress rule that gives node group access.
	ClusterIngressRule ec2.SecurityGroupRuleInput `pulumi:"clusterIngressRule"`
	// The number of worker nodes that should be running in the cluster. Defaults to 2.
	DesiredCapacity pulumi.IntPtrInput `pulumi:"desiredCapacity"`
	// Encrypt the root block device of the nodes in the node group.
	EncryptRootBlockDevice pulumi.BoolPtrInput `pulumi:"encryptRootBlockDevice"`
	// Extra security groups to attach on all nodes in this worker node group.
	//
	// This additional set of security groups captures any user application rules that will be needed for the nodes.
	ExtraNodeSecurityGroups ec2.SecurityGroupArrayInput `pulumi:"extraNodeSecurityGroups"`
	// Use the latest recommended EKS Optimized Linux AMI with GPU support for the worker nodes from the AWS Systems Manager Parameter Store.
	//
	// Defaults to false.
	//
	// Note: `gpu` and `amiId` are mutually exclusive.
	//
	// See for more details:
	// - https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html
	// - https://docs.aws.amazon.com/eks/latest/userguide/retrieve-ami-id.html
	Gpu pulumi.BoolPtrInput `pulumi:"gpu"`
	// The ingress rule that gives node group access.
	InstanceProfile *iam.InstanceProfile `pulumi:"instanceProfile"`
	// The instance type to use for the cluster's nodes. Defaults to "t2.medium".
	InstanceType pulumi.StringPtrInput `pulumi:"instanceType"`
	// Name of the key pair to use for SSH access to worker nodes.
	KeyName pulumi.StringPtrInput `pulumi:"keyName"`
	// Extra args to pass to the Kubelet. Corresponds to the options passed in the `--kubeletExtraArgs` flag to `/etc/eks/bootstrap.sh`. For example, '--port=10251 --address=0.0.0.0'. Note that the `labels` and `taints` properties will be applied to this list (using `--node-labels` and `--register-with-taints` respectively) after to the explicit `kubeletExtraArgs`.
	KubeletExtraArgs *string `pulumi:"kubeletExtraArgs"`
	// Custom k8s node labels to be attached to each worker node. Adds the given key/value pairs to the `--node-labels` kubelet argument.
	Labels map[string]string `pulumi:"labels"`
	// The maximum number of worker nodes running in the cluster. Defaults to 2.
	MaxSize pulumi.IntPtrInput `pulumi:"maxSize"`
	// The minimum number of worker nodes running in the cluster. Defaults to 1.
	MinSize pulumi.IntPtrInput `pulumi:"minSize"`
	// Whether or not to auto-assign public IP addresses on the EKS worker nodes. If this toggle is set to true, the EKS workers will be auto-assigned public IPs. If false, they will not be auto-assigned public IPs.
	NodeAssociatePublicIpAddress *bool `pulumi:"nodeAssociatePublicIpAddress"`
	// Public key material for SSH access to worker nodes. See allowed formats at:
	// https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html
	// If not provided, no SSH access is enabled on VMs.
	NodePublicKey pulumi.StringPtrInput `pulumi:"nodePublicKey"`
	// The size in GiB of a cluster node's root volume. Defaults to 20.
	NodeRootVolumeSize pulumi.IntPtrInput `pulumi:"nodeRootVolumeSize"`
	// The security group for the worker node group to communicate with the cluster.
	//
	// This security group requires specific inbound and outbound rules.
	//
	// See for more details:
	// https://docs.aws.amazon.com/eks/latest/userguide/sec-group-reqs.html
	//
	// Note: The `nodeSecurityGroup` option and the cluster option`nodeSecurityGroupTags` are mutually exclusive.
	NodeSecurityGroup ec2.SecurityGroupInput `pulumi:"nodeSecurityGroup"`
	// The set of subnets to override and use for the worker node group.
	//
	// Setting this option overrides which subnets to use for the worker node group, regardless if the cluster's `subnetIds` is set, or if `publicSubnetIds` and/or `privateSubnetIds` were set.
	NodeSubnetIds pulumi.StringArrayInput `pulumi:"nodeSubnetIds"`
	// Extra code to run on node startup. This code will run after the AWS EKS bootstrapping code and before the node signals its readiness to the managing CloudFormation stack. This code must be a typical user data script: critically it must begin with an interpreter directive (i.e. a `#!`).
	NodeUserData pulumi.StringPtrInput `pulumi:"nodeUserData"`
	// User specified code to run on node startup. This code is expected to handle the full AWS EKS bootstrapping code and signal node readiness to the managing CloudFormation stack. This code must be a complete and executable user data script in bash (Linux) or powershell (Windows).
	//
	// See for more details: https://docs.aws.amazon.com/eks/latest/userguide/worker.html
	NodeUserDataOverride pulumi.StringPtrInput `pulumi:"nodeUserDataOverride"`
	// Bidding price for spot instance. If set, only spot instances will be added as worker node.
	SpotPrice pulumi.StringPtrInput `pulumi:"spotPrice"`
	// Custom k8s node taints to be attached to each worker node. Adds the given taints to the `--register-with-taints` kubelet argument
	Taints map[string]TaintArgs `pulumi:"taints"`
	// Desired Kubernetes master / control plane version. If you do not specify a value, the latest available version is used.
	Version pulumi.StringPtrInput `pulumi:"version"`
}

Describes the configuration options accepted by a cluster to create its own node groups.

func (ClusterNodeGroupOptionsArgs) ElementType

func (ClusterNodeGroupOptionsArgs) ToClusterNodeGroupOptionsOutput

func (i ClusterNodeGroupOptionsArgs) ToClusterNodeGroupOptionsOutput() ClusterNodeGroupOptionsOutput

func (ClusterNodeGroupOptionsArgs) ToClusterNodeGroupOptionsOutputWithContext

func (i ClusterNodeGroupOptionsArgs) ToClusterNodeGroupOptionsOutputWithContext(ctx context.Context) ClusterNodeGroupOptionsOutput

func (ClusterNodeGroupOptionsArgs) ToClusterNodeGroupOptionsPtrOutput

func (i ClusterNodeGroupOptionsArgs) ToClusterNodeGroupOptionsPtrOutput() ClusterNodeGroupOptionsPtrOutput

func (ClusterNodeGroupOptionsArgs) ToClusterNodeGroupOptionsPtrOutputWithContext

func (i ClusterNodeGroupOptionsArgs) ToClusterNodeGroupOptionsPtrOutputWithContext(ctx context.Context) ClusterNodeGroupOptionsPtrOutput

func (ClusterNodeGroupOptionsArgs) ToOutput

type ClusterNodeGroupOptionsInput

type ClusterNodeGroupOptionsInput interface {
	pulumi.Input

	ToClusterNodeGroupOptionsOutput() ClusterNodeGroupOptionsOutput
	ToClusterNodeGroupOptionsOutputWithContext(context.Context) ClusterNodeGroupOptionsOutput
}

ClusterNodeGroupOptionsInput is an input type that accepts ClusterNodeGroupOptionsArgs and ClusterNodeGroupOptionsOutput values. You can construct a concrete instance of `ClusterNodeGroupOptionsInput` via:

ClusterNodeGroupOptionsArgs{...}

type ClusterNodeGroupOptionsOutput

type ClusterNodeGroupOptionsOutput struct{ *pulumi.OutputState }

Describes the configuration options accepted by a cluster to create its own node groups.

func (ClusterNodeGroupOptionsOutput) AmiId

The AMI ID to use for the worker nodes.

Defaults to the latest recommended EKS Optimized Linux AMI from the AWS Systems Manager Parameter Store.

Note: `amiId` and `gpu` are mutually exclusive.

See for more details: - https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html.

func (ClusterNodeGroupOptionsOutput) AmiType

The AMI Type to use for the worker nodes.

Only applicable when setting an AMI ID that is of type `arm64`.

Note: `amiType` and `gpu` are mutually exclusive.

func (ClusterNodeGroupOptionsOutput) AutoScalingGroupTags

func (o ClusterNodeGroupOptionsOutput) AutoScalingGroupTags() pulumi.StringMapOutput

The tags to apply to the NodeGroup's AutoScalingGroup in the CloudFormation Stack.

Per AWS, all stack-level tags, including automatically created tags, and the `cloudFormationTags` option are propagated to resources that AWS CloudFormation supports, including the AutoScalingGroup. See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-resource-tags.html

Note: Given the inheritance of auto-generated CF tags and `cloudFormationTags`, you should either supply the tag in `autoScalingGroupTags` or `cloudFormationTags`, but not both.

func (ClusterNodeGroupOptionsOutput) BootstrapExtraArgs

func (o ClusterNodeGroupOptionsOutput) BootstrapExtraArgs() pulumi.StringPtrOutput

Additional args to pass directly to `/etc/eks/bootstrap.sh`. For details on available options, see: https://github.com/awslabs/amazon-eks-ami/blob/master/files/bootstrap.sh. Note that the `--apiserver-endpoint`, `--b64-cluster-ca` and `--kubelet-extra-args` flags are included automatically based on other configuration parameters.

func (ClusterNodeGroupOptionsOutput) CloudFormationTags

func (o ClusterNodeGroupOptionsOutput) CloudFormationTags() pulumi.StringMapOutput

The tags to apply to the CloudFormation Stack of the Worker NodeGroup.

Note: Given the inheritance of auto-generated CF tags and `cloudFormationTags`, you should either supply the tag in `autoScalingGroupTags` or `cloudFormationTags`, but not both.

func (ClusterNodeGroupOptionsOutput) ClusterIngressRule

The ingress rule that gives node group access.

func (ClusterNodeGroupOptionsOutput) DesiredCapacity

The number of worker nodes that should be running in the cluster. Defaults to 2.

func (ClusterNodeGroupOptionsOutput) ElementType

func (ClusterNodeGroupOptionsOutput) EncryptRootBlockDevice

func (o ClusterNodeGroupOptionsOutput) EncryptRootBlockDevice() pulumi.BoolPtrOutput

Encrypt the root block device of the nodes in the node group.

func (ClusterNodeGroupOptionsOutput) ExtraNodeSecurityGroups

func (o ClusterNodeGroupOptionsOutput) ExtraNodeSecurityGroups() ec2.SecurityGroupArrayOutput

Extra security groups to attach on all nodes in this worker node group.

This additional set of security groups captures any user application rules that will be needed for the nodes.

func (ClusterNodeGroupOptionsOutput) Gpu

Use the latest recommended EKS Optimized Linux AMI with GPU support for the worker nodes from the AWS Systems Manager Parameter Store.

Defaults to false.

Note: `gpu` and `amiId` are mutually exclusive.

See for more details: - https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html - https://docs.aws.amazon.com/eks/latest/userguide/retrieve-ami-id.html

func (ClusterNodeGroupOptionsOutput) InstanceProfile

The ingress rule that gives node group access.

func (ClusterNodeGroupOptionsOutput) InstanceType

The instance type to use for the cluster's nodes. Defaults to "t2.medium".

func (ClusterNodeGroupOptionsOutput) KeyName

Name of the key pair to use for SSH access to worker nodes.

func (ClusterNodeGroupOptionsOutput) KubeletExtraArgs

Extra args to pass to the Kubelet. Corresponds to the options passed in the `--kubeletExtraArgs` flag to `/etc/eks/bootstrap.sh`. For example, '--port=10251 --address=0.0.0.0'. Note that the `labels` and `taints` properties will be applied to this list (using `--node-labels` and `--register-with-taints` respectively) after to the explicit `kubeletExtraArgs`.

func (ClusterNodeGroupOptionsOutput) Labels

Custom k8s node labels to be attached to each worker node. Adds the given key/value pairs to the `--node-labels` kubelet argument.

func (ClusterNodeGroupOptionsOutput) MaxSize

The maximum number of worker nodes running in the cluster. Defaults to 2.

func (ClusterNodeGroupOptionsOutput) MinSize

The minimum number of worker nodes running in the cluster. Defaults to 1.

func (ClusterNodeGroupOptionsOutput) NodeAssociatePublicIpAddress

func (o ClusterNodeGroupOptionsOutput) NodeAssociatePublicIpAddress() pulumi.BoolPtrOutput

Whether or not to auto-assign public IP addresses on the EKS worker nodes. If this toggle is set to true, the EKS workers will be auto-assigned public IPs. If false, they will not be auto-assigned public IPs.

func (ClusterNodeGroupOptionsOutput) NodePublicKey

Public key material for SSH access to worker nodes. See allowed formats at: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html If not provided, no SSH access is enabled on VMs.

func (ClusterNodeGroupOptionsOutput) NodeRootVolumeSize

func (o ClusterNodeGroupOptionsOutput) NodeRootVolumeSize() pulumi.IntPtrOutput

The size in GiB of a cluster node's root volume. Defaults to 20.

func (ClusterNodeGroupOptionsOutput) NodeSecurityGroup

The security group for the worker node group to communicate with the cluster.

This security group requires specific inbound and outbound rules.

See for more details: https://docs.aws.amazon.com/eks/latest/userguide/sec-group-reqs.html

Note: The `nodeSecurityGroup` option and the cluster option`nodeSecurityGroupTags` are mutually exclusive.

func (ClusterNodeGroupOptionsOutput) NodeSubnetIds

The set of subnets to override and use for the worker node group.

Setting this option overrides which subnets to use for the worker node group, regardless if the cluster's `subnetIds` is set, or if `publicSubnetIds` and/or `privateSubnetIds` were set.

func (ClusterNodeGroupOptionsOutput) NodeUserData

Extra code to run on node startup. This code will run after the AWS EKS bootstrapping code and before the node signals its readiness to the managing CloudFormation stack. This code must be a typical user data script: critically it must begin with an interpreter directive (i.e. a `#!`).

func (ClusterNodeGroupOptionsOutput) NodeUserDataOverride

func (o ClusterNodeGroupOptionsOutput) NodeUserDataOverride() pulumi.StringPtrOutput

User specified code to run on node startup. This code is expected to handle the full AWS EKS bootstrapping code and signal node readiness to the managing CloudFormation stack. This code must be a complete and executable user data script in bash (Linux) or powershell (Windows).

See for more details: https://docs.aws.amazon.com/eks/latest/userguide/worker.html

func (ClusterNodeGroupOptionsOutput) SpotPrice

Bidding price for spot instance. If set, only spot instances will be added as worker node.

func (ClusterNodeGroupOptionsOutput) Taints

Custom k8s node taints to be attached to each worker node. Adds the given taints to the `--register-with-taints` kubelet argument

func (ClusterNodeGroupOptionsOutput) ToClusterNodeGroupOptionsOutput

func (o ClusterNodeGroupOptionsOutput) ToClusterNodeGroupOptionsOutput() ClusterNodeGroupOptionsOutput

func (ClusterNodeGroupOptionsOutput) ToClusterNodeGroupOptionsOutputWithContext

func (o ClusterNodeGroupOptionsOutput) ToClusterNodeGroupOptionsOutputWithContext(ctx context.Context) ClusterNodeGroupOptionsOutput

func (ClusterNodeGroupOptionsOutput) ToClusterNodeGroupOptionsPtrOutput

func (o ClusterNodeGroupOptionsOutput) ToClusterNodeGroupOptionsPtrOutput() ClusterNodeGroupOptionsPtrOutput

func (ClusterNodeGroupOptionsOutput) ToClusterNodeGroupOptionsPtrOutputWithContext

func (o ClusterNodeGroupOptionsOutput) ToClusterNodeGroupOptionsPtrOutputWithContext(ctx context.Context) ClusterNodeGroupOptionsPtrOutput

func (ClusterNodeGroupOptionsOutput) ToOutput

func (ClusterNodeGroupOptionsOutput) Version

Desired Kubernetes master / control plane version. If you do not specify a value, the latest available version is used.

type ClusterNodeGroupOptionsPtrInput

type ClusterNodeGroupOptionsPtrInput interface {
	pulumi.Input

	ToClusterNodeGroupOptionsPtrOutput() ClusterNodeGroupOptionsPtrOutput
	ToClusterNodeGroupOptionsPtrOutputWithContext(context.Context) ClusterNodeGroupOptionsPtrOutput
}

ClusterNodeGroupOptionsPtrInput is an input type that accepts ClusterNodeGroupOptionsArgs, ClusterNodeGroupOptionsPtr and ClusterNodeGroupOptionsPtrOutput values. You can construct a concrete instance of `ClusterNodeGroupOptionsPtrInput` via:

        ClusterNodeGroupOptionsArgs{...}

or:

        nil

type ClusterNodeGroupOptionsPtrOutput

type ClusterNodeGroupOptionsPtrOutput struct{ *pulumi.OutputState }

func (ClusterNodeGroupOptionsPtrOutput) AmiId

The AMI ID to use for the worker nodes.

Defaults to the latest recommended EKS Optimized Linux AMI from the AWS Systems Manager Parameter Store.

Note: `amiId` and `gpu` are mutually exclusive.

See for more details: - https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html.

func (ClusterNodeGroupOptionsPtrOutput) AmiType

The AMI Type to use for the worker nodes.

Only applicable when setting an AMI ID that is of type `arm64`.

Note: `amiType` and `gpu` are mutually exclusive.

func (ClusterNodeGroupOptionsPtrOutput) AutoScalingGroupTags

func (o ClusterNodeGroupOptionsPtrOutput) AutoScalingGroupTags() pulumi.StringMapOutput

The tags to apply to the NodeGroup's AutoScalingGroup in the CloudFormation Stack.

Per AWS, all stack-level tags, including automatically created tags, and the `cloudFormationTags` option are propagated to resources that AWS CloudFormation supports, including the AutoScalingGroup. See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-resource-tags.html

Note: Given the inheritance of auto-generated CF tags and `cloudFormationTags`, you should either supply the tag in `autoScalingGroupTags` or `cloudFormationTags`, but not both.

func (ClusterNodeGroupOptionsPtrOutput) BootstrapExtraArgs

Additional args to pass directly to `/etc/eks/bootstrap.sh`. For details on available options, see: https://github.com/awslabs/amazon-eks-ami/blob/master/files/bootstrap.sh. Note that the `--apiserver-endpoint`, `--b64-cluster-ca` and `--kubelet-extra-args` flags are included automatically based on other configuration parameters.

func (ClusterNodeGroupOptionsPtrOutput) CloudFormationTags

The tags to apply to the CloudFormation Stack of the Worker NodeGroup.

Note: Given the inheritance of auto-generated CF tags and `cloudFormationTags`, you should either supply the tag in `autoScalingGroupTags` or `cloudFormationTags`, but not both.

func (ClusterNodeGroupOptionsPtrOutput) ClusterIngressRule

The ingress rule that gives node group access.

func (ClusterNodeGroupOptionsPtrOutput) DesiredCapacity

The number of worker nodes that should be running in the cluster. Defaults to 2.

func (ClusterNodeGroupOptionsPtrOutput) Elem

func (ClusterNodeGroupOptionsPtrOutput) ElementType

func (ClusterNodeGroupOptionsPtrOutput) EncryptRootBlockDevice

func (o ClusterNodeGroupOptionsPtrOutput) EncryptRootBlockDevice() pulumi.BoolPtrOutput

Encrypt the root block device of the nodes in the node group.

func (ClusterNodeGroupOptionsPtrOutput) ExtraNodeSecurityGroups

Extra security groups to attach on all nodes in this worker node group.

This additional set of security groups captures any user application rules that will be needed for the nodes.

func (ClusterNodeGroupOptionsPtrOutput) Gpu

Use the latest recommended EKS Optimized Linux AMI with GPU support for the worker nodes from the AWS Systems Manager Parameter Store.

Defaults to false.

Note: `gpu` and `amiId` are mutually exclusive.

See for more details: - https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html - https://docs.aws.amazon.com/eks/latest/userguide/retrieve-ami-id.html

func (ClusterNodeGroupOptionsPtrOutput) InstanceProfile

The ingress rule that gives node group access.

func (ClusterNodeGroupOptionsPtrOutput) InstanceType

The instance type to use for the cluster's nodes. Defaults to "t2.medium".

func (ClusterNodeGroupOptionsPtrOutput) KeyName

Name of the key pair to use for SSH access to worker nodes.

func (ClusterNodeGroupOptionsPtrOutput) KubeletExtraArgs

Extra args to pass to the Kubelet. Corresponds to the options passed in the `--kubeletExtraArgs` flag to `/etc/eks/bootstrap.sh`. For example, '--port=10251 --address=0.0.0.0'. Note that the `labels` and `taints` properties will be applied to this list (using `--node-labels` and `--register-with-taints` respectively) after to the explicit `kubeletExtraArgs`.

func (ClusterNodeGroupOptionsPtrOutput) Labels

Custom k8s node labels to be attached to each worker node. Adds the given key/value pairs to the `--node-labels` kubelet argument.

func (ClusterNodeGroupOptionsPtrOutput) MaxSize

The maximum number of worker nodes running in the cluster. Defaults to 2.

func (ClusterNodeGroupOptionsPtrOutput) MinSize

The minimum number of worker nodes running in the cluster. Defaults to 1.

func (ClusterNodeGroupOptionsPtrOutput) NodeAssociatePublicIpAddress

func (o ClusterNodeGroupOptionsPtrOutput) NodeAssociatePublicIpAddress() pulumi.BoolPtrOutput

Whether or not to auto-assign public IP addresses on the EKS worker nodes. If this toggle is set to true, the EKS workers will be auto-assigned public IPs. If false, they will not be auto-assigned public IPs.

func (ClusterNodeGroupOptionsPtrOutput) NodePublicKey

Public key material for SSH access to worker nodes. See allowed formats at: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html If not provided, no SSH access is enabled on VMs.

func (ClusterNodeGroupOptionsPtrOutput) NodeRootVolumeSize

func (o ClusterNodeGroupOptionsPtrOutput) NodeRootVolumeSize() pulumi.IntPtrOutput

The size in GiB of a cluster node's root volume. Defaults to 20.

func (ClusterNodeGroupOptionsPtrOutput) NodeSecurityGroup

The security group for the worker node group to communicate with the cluster.

This security group requires specific inbound and outbound rules.

See for more details: https://docs.aws.amazon.com/eks/latest/userguide/sec-group-reqs.html

Note: The `nodeSecurityGroup` option and the cluster option`nodeSecurityGroupTags` are mutually exclusive.

func (ClusterNodeGroupOptionsPtrOutput) NodeSubnetIds

The set of subnets to override and use for the worker node group.

Setting this option overrides which subnets to use for the worker node group, regardless if the cluster's `subnetIds` is set, or if `publicSubnetIds` and/or `privateSubnetIds` were set.

func (ClusterNodeGroupOptionsPtrOutput) NodeUserData

Extra code to run on node startup. This code will run after the AWS EKS bootstrapping code and before the node signals its readiness to the managing CloudFormation stack. This code must be a typical user data script: critically it must begin with an interpreter directive (i.e. a `#!`).

func (ClusterNodeGroupOptionsPtrOutput) NodeUserDataOverride

func (o ClusterNodeGroupOptionsPtrOutput) NodeUserDataOverride() pulumi.StringPtrOutput

User specified code to run on node startup. This code is expected to handle the full AWS EKS bootstrapping code and signal node readiness to the managing CloudFormation stack. This code must be a complete and executable user data script in bash (Linux) or powershell (Windows).

See for more details: https://docs.aws.amazon.com/eks/latest/userguide/worker.html

func (ClusterNodeGroupOptionsPtrOutput) SpotPrice

Bidding price for spot instance. If set, only spot instances will be added as worker node.

func (ClusterNodeGroupOptionsPtrOutput) Taints

Custom k8s node taints to be attached to each worker node. Adds the given taints to the `--register-with-taints` kubelet argument

func (ClusterNodeGroupOptionsPtrOutput) ToClusterNodeGroupOptionsPtrOutput

func (o ClusterNodeGroupOptionsPtrOutput) ToClusterNodeGroupOptionsPtrOutput() ClusterNodeGroupOptionsPtrOutput

func (ClusterNodeGroupOptionsPtrOutput) ToClusterNodeGroupOptionsPtrOutputWithContext

func (o ClusterNodeGroupOptionsPtrOutput) ToClusterNodeGroupOptionsPtrOutputWithContext(ctx context.Context) ClusterNodeGroupOptionsPtrOutput

func (ClusterNodeGroupOptionsPtrOutput) ToOutput

func (ClusterNodeGroupOptionsPtrOutput) Version

Desired Kubernetes master / control plane version. If you do not specify a value, the latest available version is used.

type ClusterOutput

type ClusterOutput struct{ *pulumi.OutputState }

func (ClusterOutput) AwsProvider

func (o ClusterOutput) AwsProvider() aws.ProviderOutput

The AWS resource provider.

func (ClusterOutput) ClusterSecurityGroup

func (o ClusterOutput) ClusterSecurityGroup() ec2.SecurityGroupOutput

The security group for the EKS cluster.

func (ClusterOutput) Core

func (o ClusterOutput) Core() CoreDataOutput

The EKS cluster and its dependencies.

func (ClusterOutput) DefaultNodeGroup

func (o ClusterOutput) DefaultNodeGroup() NodeGroupDataPtrOutput

The default Node Group configuration, or undefined if `skipDefaultNodeGroup` was specified.

func (ClusterOutput) EksCluster

func (o ClusterOutput) EksCluster() eks.ClusterOutput

The EKS cluster.

func (ClusterOutput) EksClusterIngressRule

func (o ClusterOutput) EksClusterIngressRule() ec2.SecurityGroupRuleOutput

The ingress rule that gives node group access to cluster API server.

func (ClusterOutput) ElementType

func (ClusterOutput) ElementType() reflect.Type

func (ClusterOutput) InstanceRoles

func (o ClusterOutput) InstanceRoles() iam.RoleArrayOutput

The service roles used by the EKS cluster.

func (ClusterOutput) Kubeconfig

func (o ClusterOutput) Kubeconfig() pulumi.AnyOutput

A kubeconfig that can be used to connect to the EKS cluster.

func (ClusterOutput) KubeconfigJson

func (o ClusterOutput) KubeconfigJson() pulumi.StringOutput

A kubeconfig that can be used to connect to the EKS cluster as a JSON string.

func (ClusterOutput) NodeSecurityGroup

func (o ClusterOutput) NodeSecurityGroup() ec2.SecurityGroupOutput

The security group for the cluster's nodes.

func (ClusterOutput) ToClusterOutput

func (o ClusterOutput) ToClusterOutput() ClusterOutput

func (ClusterOutput) ToClusterOutputWithContext

func (o ClusterOutput) ToClusterOutputWithContext(ctx context.Context) ClusterOutput

func (ClusterOutput) ToOutput

func (o ClusterOutput) ToOutput(ctx context.Context) pulumix.Output[*Cluster]

type CoreData

type CoreData struct {
	AwsProvider *aws.Provider `pulumi:"awsProvider"`
	Cluster     *eks.Cluster  `pulumi:"cluster"`
	// The IAM Role attached to the EKS Cluster
	ClusterIamRole        *iam.Role                          `pulumi:"clusterIamRole"`
	ClusterSecurityGroup  *ec2.SecurityGroup                 `pulumi:"clusterSecurityGroup"`
	EksNodeAccess         *corev1.ConfigMap                  `pulumi:"eksNodeAccess"`
	EncryptionConfig      *eks.ClusterEncryptionConfig       `pulumi:"encryptionConfig"`
	Endpoint              string                             `pulumi:"endpoint"`
	FargateProfile        *eks.FargateProfile                `pulumi:"fargateProfile"`
	InstanceRoles         []*iam.Role                        `pulumi:"instanceRoles"`
	Kubeconfig            interface{}                        `pulumi:"kubeconfig"`
	NodeGroupOptions      ClusterNodeGroupOptions            `pulumi:"nodeGroupOptions"`
	NodeSecurityGroupTags map[string]string                  `pulumi:"nodeSecurityGroupTags"`
	OidcProvider          *iam.OpenIdConnectProvider         `pulumi:"oidcProvider"`
	PrivateSubnetIds      []string                           `pulumi:"privateSubnetIds"`
	Provider              *kubernetes.Provider               `pulumi:"provider"`
	PublicSubnetIds       []string                           `pulumi:"publicSubnetIds"`
	StorageClasses        map[string]*storagev1.StorageClass `pulumi:"storageClasses"`
	SubnetIds             []string                           `pulumi:"subnetIds"`
	Tags                  map[string]string                  `pulumi:"tags"`
	VpcCni                *VpcCni                            `pulumi:"vpcCni"`
	VpcId                 string                             `pulumi:"vpcId"`
}

Defines the core set of data associated with an EKS cluster, including the network in which it runs.

type CoreDataOutput

type CoreDataOutput struct{ *pulumi.OutputState }

Defines the core set of data associated with an EKS cluster, including the network in which it runs.

func (CoreDataOutput) AwsProvider

func (o CoreDataOutput) AwsProvider() aws.ProviderOutput

func (CoreDataOutput) Cluster

func (o CoreDataOutput) Cluster() eks.ClusterOutput

func (CoreDataOutput) ClusterIamRole

func (o CoreDataOutput) ClusterIamRole() iam.RoleOutput

The IAM Role attached to the EKS Cluster

func (CoreDataOutput) ClusterSecurityGroup

func (o CoreDataOutput) ClusterSecurityGroup() ec2.SecurityGroupOutput

func (CoreDataOutput) EksNodeAccess

func (o CoreDataOutput) EksNodeAccess() corev1.ConfigMapOutput

func (CoreDataOutput) ElementType

func (CoreDataOutput) ElementType() reflect.Type

func (CoreDataOutput) EncryptionConfig

func (CoreDataOutput) Endpoint

func (o CoreDataOutput) Endpoint() pulumi.StringOutput

func (CoreDataOutput) FargateProfile

func (o CoreDataOutput) FargateProfile() eks.FargateProfileOutput

func (CoreDataOutput) InstanceRoles

func (o CoreDataOutput) InstanceRoles() iam.RoleArrayOutput

func (CoreDataOutput) Kubeconfig

func (o CoreDataOutput) Kubeconfig() pulumi.AnyOutput

func (CoreDataOutput) NodeGroupOptions

func (o CoreDataOutput) NodeGroupOptions() ClusterNodeGroupOptionsOutput

func (CoreDataOutput) NodeSecurityGroupTags

func (o CoreDataOutput) NodeSecurityGroupTags() pulumi.StringMapOutput

func (CoreDataOutput) OidcProvider

func (CoreDataOutput) PrivateSubnetIds

func (o CoreDataOutput) PrivateSubnetIds() pulumi.StringArrayOutput

func (CoreDataOutput) Provider

func (CoreDataOutput) PublicSubnetIds

func (o CoreDataOutput) PublicSubnetIds() pulumi.StringArrayOutput

func (CoreDataOutput) StorageClasses

func (o CoreDataOutput) StorageClasses() storagev1.StorageClassMapOutput

func (CoreDataOutput) SubnetIds

func (o CoreDataOutput) SubnetIds() pulumi.StringArrayOutput

func (CoreDataOutput) Tags

func (CoreDataOutput) ToCoreDataOutput

func (o CoreDataOutput) ToCoreDataOutput() CoreDataOutput

func (CoreDataOutput) ToCoreDataOutputWithContext

func (o CoreDataOutput) ToCoreDataOutputWithContext(ctx context.Context) CoreDataOutput

func (CoreDataOutput) ToOutput

func (CoreDataOutput) VpcCni

func (o CoreDataOutput) VpcCni() VpcCniOutput

func (CoreDataOutput) VpcId

type CreationRoleProvider

type CreationRoleProvider struct {
	Provider *aws.Provider `pulumi:"provider"`
	Role     *iam.Role     `pulumi:"role"`
}

Contains the AWS Role and Provider necessary to override the `[system:master]` entity ARN. This is an optional argument used when creating `Cluster`. Read more: https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html

type CreationRoleProviderArgs

type CreationRoleProviderArgs struct {
	Provider *aws.Provider `pulumi:"provider"`
	Role     *iam.Role     `pulumi:"role"`
}

Contains the AWS Role and Provider necessary to override the `[system:master]` entity ARN. This is an optional argument used when creating `Cluster`. Read more: https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html

func (CreationRoleProviderArgs) ElementType

func (CreationRoleProviderArgs) ElementType() reflect.Type

func (CreationRoleProviderArgs) ToCreationRoleProviderOutput

func (i CreationRoleProviderArgs) ToCreationRoleProviderOutput() CreationRoleProviderOutput

func (CreationRoleProviderArgs) ToCreationRoleProviderOutputWithContext

func (i CreationRoleProviderArgs) ToCreationRoleProviderOutputWithContext(ctx context.Context) CreationRoleProviderOutput

func (CreationRoleProviderArgs) ToCreationRoleProviderPtrOutput

func (i CreationRoleProviderArgs) ToCreationRoleProviderPtrOutput() CreationRoleProviderPtrOutput

func (CreationRoleProviderArgs) ToCreationRoleProviderPtrOutputWithContext

func (i CreationRoleProviderArgs) ToCreationRoleProviderPtrOutputWithContext(ctx context.Context) CreationRoleProviderPtrOutput

func (CreationRoleProviderArgs) ToOutput

type CreationRoleProviderInput

type CreationRoleProviderInput interface {
	pulumi.Input

	ToCreationRoleProviderOutput() CreationRoleProviderOutput
	ToCreationRoleProviderOutputWithContext(context.Context) CreationRoleProviderOutput
}

CreationRoleProviderInput is an input type that accepts CreationRoleProviderArgs and CreationRoleProviderOutput values. You can construct a concrete instance of `CreationRoleProviderInput` via:

CreationRoleProviderArgs{...}

type CreationRoleProviderOutput

type CreationRoleProviderOutput struct{ *pulumi.OutputState }

Contains the AWS Role and Provider necessary to override the `[system:master]` entity ARN. This is an optional argument used when creating `Cluster`. Read more: https://docs.aws.amazon.com/eks/latest/userguide/add-user-role.html

func (CreationRoleProviderOutput) ElementType

func (CreationRoleProviderOutput) ElementType() reflect.Type

func (CreationRoleProviderOutput) Provider

func (CreationRoleProviderOutput) Role

func (CreationRoleProviderOutput) ToCreationRoleProviderOutput

func (o CreationRoleProviderOutput) ToCreationRoleProviderOutput() CreationRoleProviderOutput

func (CreationRoleProviderOutput) ToCreationRoleProviderOutputWithContext

func (o CreationRoleProviderOutput) ToCreationRoleProviderOutputWithContext(ctx context.Context) CreationRoleProviderOutput

func (CreationRoleProviderOutput) ToCreationRoleProviderPtrOutput

func (o CreationRoleProviderOutput) ToCreationRoleProviderPtrOutput() CreationRoleProviderPtrOutput

func (CreationRoleProviderOutput) ToCreationRoleProviderPtrOutputWithContext

func (o CreationRoleProviderOutput) ToCreationRoleProviderPtrOutputWithContext(ctx context.Context) CreationRoleProviderPtrOutput

func (CreationRoleProviderOutput) ToOutput

type CreationRoleProviderPtrInput

type CreationRoleProviderPtrInput interface {
	pulumi.Input

	ToCreationRoleProviderPtrOutput() CreationRoleProviderPtrOutput
	ToCreationRoleProviderPtrOutputWithContext(context.Context) CreationRoleProviderPtrOutput
}

CreationRoleProviderPtrInput is an input type that accepts CreationRoleProviderArgs, CreationRoleProviderPtr and CreationRoleProviderPtrOutput values. You can construct a concrete instance of `CreationRoleProviderPtrInput` via:

        CreationRoleProviderArgs{...}

or:

        nil

type CreationRoleProviderPtrOutput

type CreationRoleProviderPtrOutput struct{ *pulumi.OutputState }

func (CreationRoleProviderPtrOutput) Elem

func (CreationRoleProviderPtrOutput) ElementType

func (CreationRoleProviderPtrOutput) Provider

func (CreationRoleProviderPtrOutput) Role

func (CreationRoleProviderPtrOutput) ToCreationRoleProviderPtrOutput

func (o CreationRoleProviderPtrOutput) ToCreationRoleProviderPtrOutput() CreationRoleProviderPtrOutput

func (CreationRoleProviderPtrOutput) ToCreationRoleProviderPtrOutputWithContext

func (o CreationRoleProviderPtrOutput) ToCreationRoleProviderPtrOutputWithContext(ctx context.Context) CreationRoleProviderPtrOutput

func (CreationRoleProviderPtrOutput) ToOutput

type FargateProfile

type FargateProfile struct {
	// Specify a custom role to use for executing pods in Fargate. Defaults to creating a new role with the `arn:aws:iam::aws:policy/AmazonEKSFargatePodExecutionRolePolicy` policy attached.
	PodExecutionRoleArn *string `pulumi:"podExecutionRoleArn"`
	// Specify the namespace and label selectors to use for launching pods into Fargate.
	Selectors []eks.FargateProfileSelector `pulumi:"selectors"`
	// Specify the subnets in which to execute Fargate tasks for pods. Defaults to the private subnets associated with the cluster.
	SubnetIds []string `pulumi:"subnetIds"`
}

Defines how Kubernetes pods are executed in Fargate. See aws.eks.FargateProfileArgs for reference.

type KubeconfigOptions

type KubeconfigOptions struct {
	// AWS credential profile name to always use instead of the default AWS credential provider chain.
	//
	// The profile is passed to kubeconfig as an authentication environment setting.
	ProfileName *string `pulumi:"profileName"`
	// Role ARN to assume instead of the default AWS credential provider chain.
	//
	// The role is passed to kubeconfig as an authentication exec argument.
	RoleArn *string `pulumi:"roleArn"`
}

Represents the AWS credentials to scope a given kubeconfig when using a non-default credential chain.

The options can be used independently, or additively.

A scoped kubeconfig is necessary for certain auth scenarios. For example:

  1. Assume a role on the default account caller,
  2. Use an AWS creds profile instead of the default account caller,
  3. Use an AWS creds creds profile instead of the default account caller, and then assume a given role on the profile. This scenario is also possible by only using a profile, iff the profile includes a role to assume in its settings.

See for more details: - https://docs.aws.amazon.com/eks/latest/userguide/create-kubeconfig.html - https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-role.html - https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-profiles.html

type KubeconfigOptionsArgs

type KubeconfigOptionsArgs struct {
	// AWS credential profile name to always use instead of the default AWS credential provider chain.
	//
	// The profile is passed to kubeconfig as an authentication environment setting.
	ProfileName pulumi.StringPtrInput `pulumi:"profileName"`
	// Role ARN to assume instead of the default AWS credential provider chain.
	//
	// The role is passed to kubeconfig as an authentication exec argument.
	RoleArn pulumi.StringPtrInput `pulumi:"roleArn"`
}

Represents the AWS credentials to scope a given kubeconfig when using a non-default credential chain.

The options can be used independently, or additively.

A scoped kubeconfig is necessary for certain auth scenarios. For example:

  1. Assume a role on the default account caller,
  2. Use an AWS creds profile instead of the default account caller,
  3. Use an AWS creds creds profile instead of the default account caller, and then assume a given role on the profile. This scenario is also possible by only using a profile, iff the profile includes a role to assume in its settings.

See for more details: - https://docs.aws.amazon.com/eks/latest/userguide/create-kubeconfig.html - https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-role.html - https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-profiles.html

func (KubeconfigOptionsArgs) ElementType

func (KubeconfigOptionsArgs) ElementType() reflect.Type

func (KubeconfigOptionsArgs) ToKubeconfigOptionsOutput

func (i KubeconfigOptionsArgs) ToKubeconfigOptionsOutput() KubeconfigOptionsOutput

func (KubeconfigOptionsArgs) ToKubeconfigOptionsOutputWithContext

func (i KubeconfigOptionsArgs) ToKubeconfigOptionsOutputWithContext(ctx context.Context) KubeconfigOptionsOutput

func (KubeconfigOptionsArgs) ToKubeconfigOptionsPtrOutput

func (i KubeconfigOptionsArgs) ToKubeconfigOptionsPtrOutput() KubeconfigOptionsPtrOutput

func (KubeconfigOptionsArgs) ToKubeconfigOptionsPtrOutputWithContext

func (i KubeconfigOptionsArgs) ToKubeconfigOptionsPtrOutputWithContext(ctx context.Context) KubeconfigOptionsPtrOutput

func (KubeconfigOptionsArgs) ToOutput

type KubeconfigOptionsInput

type KubeconfigOptionsInput interface {
	pulumi.Input

	ToKubeconfigOptionsOutput() KubeconfigOptionsOutput
	ToKubeconfigOptionsOutputWithContext(context.Context) KubeconfigOptionsOutput
}

KubeconfigOptionsInput is an input type that accepts KubeconfigOptionsArgs and KubeconfigOptionsOutput values. You can construct a concrete instance of `KubeconfigOptionsInput` via:

KubeconfigOptionsArgs{...}

type KubeconfigOptionsOutput

type KubeconfigOptionsOutput struct{ *pulumi.OutputState }

Represents the AWS credentials to scope a given kubeconfig when using a non-default credential chain.

The options can be used independently, or additively.

A scoped kubeconfig is necessary for certain auth scenarios. For example:

  1. Assume a role on the default account caller,
  2. Use an AWS creds profile instead of the default account caller,
  3. Use an AWS creds creds profile instead of the default account caller, and then assume a given role on the profile. This scenario is also possible by only using a profile, iff the profile includes a role to assume in its settings.

See for more details: - https://docs.aws.amazon.com/eks/latest/userguide/create-kubeconfig.html - https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-role.html - https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-profiles.html

func (KubeconfigOptionsOutput) ElementType

func (KubeconfigOptionsOutput) ElementType() reflect.Type

func (KubeconfigOptionsOutput) ProfileName

AWS credential profile name to always use instead of the default AWS credential provider chain.

The profile is passed to kubeconfig as an authentication environment setting.

func (KubeconfigOptionsOutput) RoleArn

Role ARN to assume instead of the default AWS credential provider chain.

The role is passed to kubeconfig as an authentication exec argument.

func (KubeconfigOptionsOutput) ToKubeconfigOptionsOutput

func (o KubeconfigOptionsOutput) ToKubeconfigOptionsOutput() KubeconfigOptionsOutput

func (KubeconfigOptionsOutput) ToKubeconfigOptionsOutputWithContext

func (o KubeconfigOptionsOutput) ToKubeconfigOptionsOutputWithContext(ctx context.Context) KubeconfigOptionsOutput

func (KubeconfigOptionsOutput) ToKubeconfigOptionsPtrOutput

func (o KubeconfigOptionsOutput) ToKubeconfigOptionsPtrOutput() KubeconfigOptionsPtrOutput

func (KubeconfigOptionsOutput) ToKubeconfigOptionsPtrOutputWithContext

func (o KubeconfigOptionsOutput) ToKubeconfigOptionsPtrOutputWithContext(ctx context.Context) KubeconfigOptionsPtrOutput

func (KubeconfigOptionsOutput) ToOutput

type KubeconfigOptionsPtrInput

type KubeconfigOptionsPtrInput interface {
	pulumi.Input

	ToKubeconfigOptionsPtrOutput() KubeconfigOptionsPtrOutput
	ToKubeconfigOptionsPtrOutputWithContext(context.Context) KubeconfigOptionsPtrOutput
}

KubeconfigOptionsPtrInput is an input type that accepts KubeconfigOptionsArgs, KubeconfigOptionsPtr and KubeconfigOptionsPtrOutput values. You can construct a concrete instance of `KubeconfigOptionsPtrInput` via:

        KubeconfigOptionsArgs{...}

or:

        nil

type KubeconfigOptionsPtrOutput

type KubeconfigOptionsPtrOutput struct{ *pulumi.OutputState }

func (KubeconfigOptionsPtrOutput) Elem

func (KubeconfigOptionsPtrOutput) ElementType

func (KubeconfigOptionsPtrOutput) ElementType() reflect.Type

func (KubeconfigOptionsPtrOutput) ProfileName

AWS credential profile name to always use instead of the default AWS credential provider chain.

The profile is passed to kubeconfig as an authentication environment setting.

func (KubeconfigOptionsPtrOutput) RoleArn

Role ARN to assume instead of the default AWS credential provider chain.

The role is passed to kubeconfig as an authentication exec argument.

func (KubeconfigOptionsPtrOutput) ToKubeconfigOptionsPtrOutput

func (o KubeconfigOptionsPtrOutput) ToKubeconfigOptionsPtrOutput() KubeconfigOptionsPtrOutput

func (KubeconfigOptionsPtrOutput) ToKubeconfigOptionsPtrOutputWithContext

func (o KubeconfigOptionsPtrOutput) ToKubeconfigOptionsPtrOutputWithContext(ctx context.Context) KubeconfigOptionsPtrOutput

func (KubeconfigOptionsPtrOutput) ToOutput

type ManagedNodeGroup

type ManagedNodeGroup struct {
	pulumi.ResourceState

	// The AWS managed node group.
	NodeGroup eks.NodeGroupOutput `pulumi:"nodeGroup"`
}

ManagedNodeGroup is a component that wraps creating an AWS managed node group.

See for more details: https://docs.aws.amazon.com/eks/latest/userguide/managed-node-groups.html

func NewManagedNodeGroup

func NewManagedNodeGroup(ctx *pulumi.Context,
	name string, args *ManagedNodeGroupArgs, opts ...pulumi.ResourceOption) (*ManagedNodeGroup, error)

NewManagedNodeGroup registers a new resource with the given unique name, arguments, and options.

func (*ManagedNodeGroup) ElementType

func (*ManagedNodeGroup) ElementType() reflect.Type

func (*ManagedNodeGroup) ToManagedNodeGroupOutput

func (i *ManagedNodeGroup) ToManagedNodeGroupOutput() ManagedNodeGroupOutput

func (*ManagedNodeGroup) ToManagedNodeGroupOutputWithContext

func (i *ManagedNodeGroup) ToManagedNodeGroupOutputWithContext(ctx context.Context) ManagedNodeGroupOutput

func (*ManagedNodeGroup) ToOutput

type ManagedNodeGroupArgs

type ManagedNodeGroupArgs struct {
	// Type of Amazon Machine Image (AMI) associated with the EKS Node Group. Defaults to `AL2_x86_64`. See the AWS documentation (https://docs.aws.amazon.com/eks/latest/APIReference/API_Nodegroup.html#AmazonEKS-Type-Nodegroup-amiType) for valid AMI Types. This provider will only perform drift detection if a configuration value is provided.
	AmiType pulumi.StringPtrInput
	// Type of capacity associated with the EKS Node Group. Valid values: `ON_DEMAND`, `SPOT`. This provider will only perform drift detection if a configuration value is provided.
	CapacityType pulumi.StringPtrInput
	// The target EKS cluster.
	Cluster pulumi.Input
	// Name of the EKS Cluster.
	ClusterName pulumi.StringPtrInput
	// Disk size in GiB for worker nodes. Defaults to `20`. This provider will only perform drift detection if a configuration value is provided.
	DiskSize pulumi.IntPtrInput
	// Force version update if existing pods are unable to be drained due to a pod disruption budget issue.
	ForceUpdateVersion pulumi.BoolPtrInput
	// Set of instance types associated with the EKS Node Group. Defaults to `["t3.medium"]`. This provider will only perform drift detection if a configuration value is provided. Currently, the EKS API only accepts a single value in the set.
	InstanceTypes pulumi.StringArrayInput
	// Key-value map of Kubernetes labels. Only labels that are applied with the EKS API are managed by this argument. Other Kubernetes labels applied to the EKS Node Group will not be managed.
	Labels pulumi.StringMapInput
	// Launch Template settings.
	LaunchTemplate eks.NodeGroupLaunchTemplatePtrInput
	// Name of the EKS Node Group. If omitted, this provider will assign a random, unique name. Conflicts with `nodeGroupNamePrefix`.
	NodeGroupName pulumi.StringPtrInput
	// Creates a unique name beginning with the specified prefix. Conflicts with `nodeGroupName`.
	NodeGroupNamePrefix pulumi.StringPtrInput
	// The IAM Role that provides permissions for the EKS Node Group.
	//
	// Note, `nodeRole` and `nodeRoleArn` are mutually exclusive, and a single option must be used.
	NodeRole iam.RoleInput
	// Amazon Resource Name (ARN) of the IAM Role that provides permissions for the EKS Node Group.
	//
	// Note, `nodeRoleArn` and `nodeRole` are mutually exclusive, and a single option must be used.
	NodeRoleArn pulumi.StringPtrInput
	// AMI version of the EKS Node Group. Defaults to latest version for Kubernetes version.
	ReleaseVersion pulumi.StringPtrInput
	// Remote access settings.
	RemoteAccess eks.NodeGroupRemoteAccessPtrInput
	// Scaling settings.
	//
	// Default scaling amounts of the node group autoscaling group are:
	//   - desiredSize: 2
	//   - minSize: 1
	//   - maxSize: 2
	ScalingConfig eks.NodeGroupScalingConfigPtrInput
	// Identifiers of EC2 Subnets to associate with the EKS Node Group. These subnets must have the following resource tag: `kubernetes.io/cluster/CLUSTER_NAME` (where `CLUSTER_NAME` is replaced with the name of the EKS Cluster).
	//
	// Default subnetIds is chosen from the following list, in order, if subnetIds arg is not set:
	//   - core.subnetIds
	//   - core.privateIds
	//   - core.publicSubnetIds
	//
	// This default logic is based on the existing subnet IDs logic of this package: https://git.io/JeM11
	SubnetIds pulumi.StringArrayInput
	// Key-value mapping of resource tags.
	Tags pulumi.StringMapInput
	// The Kubernetes taints to be applied to the nodes in the node group. Maximum of 50 taints per node group.
	Taints  eks.NodeGroupTaintArrayInput
	Version pulumi.StringPtrInput
}

The set of arguments for constructing a ManagedNodeGroup resource.

func (ManagedNodeGroupArgs) ElementType

func (ManagedNodeGroupArgs) ElementType() reflect.Type

type ManagedNodeGroupArray

type ManagedNodeGroupArray []ManagedNodeGroupInput

func (ManagedNodeGroupArray) ElementType

func (ManagedNodeGroupArray) ElementType() reflect.Type

func (ManagedNodeGroupArray) ToManagedNodeGroupArrayOutput

func (i ManagedNodeGroupArray) ToManagedNodeGroupArrayOutput() ManagedNodeGroupArrayOutput

func (ManagedNodeGroupArray) ToManagedNodeGroupArrayOutputWithContext

func (i ManagedNodeGroupArray) ToManagedNodeGroupArrayOutputWithContext(ctx context.Context) ManagedNodeGroupArrayOutput

func (ManagedNodeGroupArray) ToOutput

type ManagedNodeGroupArrayInput

type ManagedNodeGroupArrayInput interface {
	pulumi.Input

	ToManagedNodeGroupArrayOutput() ManagedNodeGroupArrayOutput
	ToManagedNodeGroupArrayOutputWithContext(context.Context) ManagedNodeGroupArrayOutput
}

ManagedNodeGroupArrayInput is an input type that accepts ManagedNodeGroupArray and ManagedNodeGroupArrayOutput values. You can construct a concrete instance of `ManagedNodeGroupArrayInput` via:

ManagedNodeGroupArray{ ManagedNodeGroupArgs{...} }

type ManagedNodeGroupArrayOutput

type ManagedNodeGroupArrayOutput struct{ *pulumi.OutputState }

func (ManagedNodeGroupArrayOutput) ElementType

func (ManagedNodeGroupArrayOutput) Index

func (ManagedNodeGroupArrayOutput) ToManagedNodeGroupArrayOutput

func (o ManagedNodeGroupArrayOutput) ToManagedNodeGroupArrayOutput() ManagedNodeGroupArrayOutput

func (ManagedNodeGroupArrayOutput) ToManagedNodeGroupArrayOutputWithContext

func (o ManagedNodeGroupArrayOutput) ToManagedNodeGroupArrayOutputWithContext(ctx context.Context) ManagedNodeGroupArrayOutput

func (ManagedNodeGroupArrayOutput) ToOutput

type ManagedNodeGroupInput

type ManagedNodeGroupInput interface {
	pulumi.Input

	ToManagedNodeGroupOutput() ManagedNodeGroupOutput
	ToManagedNodeGroupOutputWithContext(ctx context.Context) ManagedNodeGroupOutput
}

type ManagedNodeGroupMap

type ManagedNodeGroupMap map[string]ManagedNodeGroupInput

func (ManagedNodeGroupMap) ElementType

func (ManagedNodeGroupMap) ElementType() reflect.Type

func (ManagedNodeGroupMap) ToManagedNodeGroupMapOutput

func (i ManagedNodeGroupMap) ToManagedNodeGroupMapOutput() ManagedNodeGroupMapOutput

func (ManagedNodeGroupMap) ToManagedNodeGroupMapOutputWithContext

func (i ManagedNodeGroupMap) ToManagedNodeGroupMapOutputWithContext(ctx context.Context) ManagedNodeGroupMapOutput

func (ManagedNodeGroupMap) ToOutput

type ManagedNodeGroupMapInput

type ManagedNodeGroupMapInput interface {
	pulumi.Input

	ToManagedNodeGroupMapOutput() ManagedNodeGroupMapOutput
	ToManagedNodeGroupMapOutputWithContext(context.Context) ManagedNodeGroupMapOutput
}

ManagedNodeGroupMapInput is an input type that accepts ManagedNodeGroupMap and ManagedNodeGroupMapOutput values. You can construct a concrete instance of `ManagedNodeGroupMapInput` via:

ManagedNodeGroupMap{ "key": ManagedNodeGroupArgs{...} }

type ManagedNodeGroupMapOutput

type ManagedNodeGroupMapOutput struct{ *pulumi.OutputState }

func (ManagedNodeGroupMapOutput) ElementType

func (ManagedNodeGroupMapOutput) ElementType() reflect.Type

func (ManagedNodeGroupMapOutput) MapIndex

func (ManagedNodeGroupMapOutput) ToManagedNodeGroupMapOutput

func (o ManagedNodeGroupMapOutput) ToManagedNodeGroupMapOutput() ManagedNodeGroupMapOutput

func (ManagedNodeGroupMapOutput) ToManagedNodeGroupMapOutputWithContext

func (o ManagedNodeGroupMapOutput) ToManagedNodeGroupMapOutputWithContext(ctx context.Context) ManagedNodeGroupMapOutput

func (ManagedNodeGroupMapOutput) ToOutput

type ManagedNodeGroupOutput

type ManagedNodeGroupOutput struct{ *pulumi.OutputState }

func (ManagedNodeGroupOutput) ElementType

func (ManagedNodeGroupOutput) ElementType() reflect.Type

func (ManagedNodeGroupOutput) NodeGroup

The AWS managed node group.

func (ManagedNodeGroupOutput) ToManagedNodeGroupOutput

func (o ManagedNodeGroupOutput) ToManagedNodeGroupOutput() ManagedNodeGroupOutput

func (ManagedNodeGroupOutput) ToManagedNodeGroupOutputWithContext

func (o ManagedNodeGroupOutput) ToManagedNodeGroupOutputWithContext(ctx context.Context) ManagedNodeGroupOutput

func (ManagedNodeGroupOutput) ToOutput

type NodeGroup

type NodeGroup struct {
	pulumi.ResourceState

	// The AutoScalingGroup name for the Node group.
	AutoScalingGroupName pulumi.StringOutput `pulumi:"autoScalingGroupName"`
	// The CloudFormation Stack which defines the Node AutoScalingGroup.
	CfnStack cloudformation.StackOutput `pulumi:"cfnStack"`
	// The additional security groups for the node group that captures user-specific rules.
	ExtraNodeSecurityGroups ec2.SecurityGroupArrayOutput `pulumi:"extraNodeSecurityGroups"`
	// The security group for the node group to communicate with the cluster.
	NodeSecurityGroup ec2.SecurityGroupOutput `pulumi:"nodeSecurityGroup"`
}

NodeGroup is a component that wraps the AWS EC2 instances that provide compute capacity for an EKS cluster.

func NewNodeGroup

func NewNodeGroup(ctx *pulumi.Context,
	name string, args *NodeGroupArgs, opts ...pulumi.ResourceOption) (*NodeGroup, error)

NewNodeGroup registers a new resource with the given unique name, arguments, and options.

func (*NodeGroup) ElementType

func (*NodeGroup) ElementType() reflect.Type

func (*NodeGroup) ToNodeGroupOutput

func (i *NodeGroup) ToNodeGroupOutput() NodeGroupOutput

func (*NodeGroup) ToNodeGroupOutputWithContext

func (i *NodeGroup) ToNodeGroupOutputWithContext(ctx context.Context) NodeGroupOutput

func (*NodeGroup) ToOutput

func (i *NodeGroup) ToOutput(ctx context.Context) pulumix.Output[*NodeGroup]

type NodeGroupArgs

type NodeGroupArgs struct {
	// The AMI ID to use for the worker nodes.
	//
	// Defaults to the latest recommended EKS Optimized Linux AMI from the AWS Systems Manager Parameter Store.
	//
	// Note: `amiId` and `gpu` are mutually exclusive.
	//
	// See for more details:
	// - https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html.
	AmiId pulumi.StringPtrInput
	// The AMI Type to use for the worker nodes.
	//
	// Only applicable when setting an AMI ID that is of type `arm64`.
	//
	// Note: `amiType` and `gpu` are mutually exclusive.
	AmiType pulumi.StringPtrInput
	// The tags to apply to the NodeGroup's AutoScalingGroup in the CloudFormation Stack.
	//
	// Per AWS, all stack-level tags, including automatically created tags, and the `cloudFormationTags` option are propagated to resources that AWS CloudFormation supports, including the AutoScalingGroup. See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-resource-tags.html
	//
	// Note: Given the inheritance of auto-generated CF tags and `cloudFormationTags`, you should either supply the tag in `autoScalingGroupTags` or `cloudFormationTags`, but not both.
	AutoScalingGroupTags pulumi.StringMapInput
	// Additional args to pass directly to `/etc/eks/bootstrap.sh`. For details on available options, see: https://github.com/awslabs/amazon-eks-ami/blob/master/files/bootstrap.sh. Note that the `--apiserver-endpoint`, `--b64-cluster-ca` and `--kubelet-extra-args` flags are included automatically based on other configuration parameters.
	BootstrapExtraArgs *string
	// The tags to apply to the CloudFormation Stack of the Worker NodeGroup.
	//
	// Note: Given the inheritance of auto-generated CF tags and `cloudFormationTags`, you should either supply the tag in `autoScalingGroupTags` or `cloudFormationTags`, but not both.
	CloudFormationTags pulumi.StringMapInput
	// The target EKS cluster.
	Cluster pulumi.Input
	// The ingress rule that gives node group access.
	ClusterIngressRule ec2.SecurityGroupRuleInput
	// The number of worker nodes that should be running in the cluster. Defaults to 2.
	DesiredCapacity pulumi.IntPtrInput
	// Encrypt the root block device of the nodes in the node group.
	EncryptRootBlockDevice pulumi.BoolPtrInput
	// Extra security groups to attach on all nodes in this worker node group.
	//
	// This additional set of security groups captures any user application rules that will be needed for the nodes.
	ExtraNodeSecurityGroups ec2.SecurityGroupArrayInput
	// Use the latest recommended EKS Optimized Linux AMI with GPU support for the worker nodes from the AWS Systems Manager Parameter Store.
	//
	// Defaults to false.
	//
	// Note: `gpu` and `amiId` are mutually exclusive.
	//
	// See for more details:
	// - https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html
	// - https://docs.aws.amazon.com/eks/latest/userguide/retrieve-ami-id.html
	Gpu pulumi.BoolPtrInput
	// The ingress rule that gives node group access.
	InstanceProfile *iam.InstanceProfile
	// The instance type to use for the cluster's nodes. Defaults to "t2.medium".
	InstanceType pulumi.StringPtrInput
	// Name of the key pair to use for SSH access to worker nodes.
	KeyName pulumi.StringPtrInput
	// Extra args to pass to the Kubelet. Corresponds to the options passed in the `--kubeletExtraArgs` flag to `/etc/eks/bootstrap.sh`. For example, '--port=10251 --address=0.0.0.0'. Note that the `labels` and `taints` properties will be applied to this list (using `--node-labels` and `--register-with-taints` respectively) after to the explicit `kubeletExtraArgs`.
	KubeletExtraArgs *string
	// Custom k8s node labels to be attached to each worker node. Adds the given key/value pairs to the `--node-labels` kubelet argument.
	Labels map[string]string
	// The maximum number of worker nodes running in the cluster. Defaults to 2.
	MaxSize pulumi.IntPtrInput
	// The minimum number of worker nodes running in the cluster. Defaults to 1.
	MinSize pulumi.IntPtrInput
	// Whether or not to auto-assign public IP addresses on the EKS worker nodes. If this toggle is set to true, the EKS workers will be auto-assigned public IPs. If false, they will not be auto-assigned public IPs.
	NodeAssociatePublicIpAddress *bool
	// Public key material for SSH access to worker nodes. See allowed formats at:
	// https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html
	// If not provided, no SSH access is enabled on VMs.
	NodePublicKey pulumi.StringPtrInput
	// The size in GiB of a cluster node's root volume. Defaults to 20.
	NodeRootVolumeSize pulumi.IntPtrInput
	// The security group for the worker node group to communicate with the cluster.
	//
	// This security group requires specific inbound and outbound rules.
	//
	// See for more details:
	// https://docs.aws.amazon.com/eks/latest/userguide/sec-group-reqs.html
	//
	// Note: The `nodeSecurityGroup` option and the cluster option`nodeSecurityGroupTags` are mutually exclusive.
	NodeSecurityGroup ec2.SecurityGroupInput
	// The set of subnets to override and use for the worker node group.
	//
	// Setting this option overrides which subnets to use for the worker node group, regardless if the cluster's `subnetIds` is set, or if `publicSubnetIds` and/or `privateSubnetIds` were set.
	NodeSubnetIds pulumi.StringArrayInput
	// Extra code to run on node startup. This code will run after the AWS EKS bootstrapping code and before the node signals its readiness to the managing CloudFormation stack. This code must be a typical user data script: critically it must begin with an interpreter directive (i.e. a `#!`).
	NodeUserData pulumi.StringPtrInput
	// User specified code to run on node startup. This code is expected to handle the full AWS EKS bootstrapping code and signal node readiness to the managing CloudFormation stack. This code must be a complete and executable user data script in bash (Linux) or powershell (Windows).
	//
	// See for more details: https://docs.aws.amazon.com/eks/latest/userguide/worker.html
	NodeUserDataOverride pulumi.StringPtrInput
	// Bidding price for spot instance. If set, only spot instances will be added as worker node.
	SpotPrice pulumi.StringPtrInput
	// Custom k8s node taints to be attached to each worker node. Adds the given taints to the `--register-with-taints` kubelet argument
	Taints map[string]TaintArgs
	// Desired Kubernetes master / control plane version. If you do not specify a value, the latest available version is used.
	Version pulumi.StringPtrInput
}

The set of arguments for constructing a NodeGroup resource.

func (NodeGroupArgs) ElementType

func (NodeGroupArgs) ElementType() reflect.Type

type NodeGroupArray

type NodeGroupArray []NodeGroupInput

func (NodeGroupArray) ElementType

func (NodeGroupArray) ElementType() reflect.Type

func (NodeGroupArray) ToNodeGroupArrayOutput

func (i NodeGroupArray) ToNodeGroupArrayOutput() NodeGroupArrayOutput

func (NodeGroupArray) ToNodeGroupArrayOutputWithContext

func (i NodeGroupArray) ToNodeGroupArrayOutputWithContext(ctx context.Context) NodeGroupArrayOutput

func (NodeGroupArray) ToOutput

func (i NodeGroupArray) ToOutput(ctx context.Context) pulumix.Output[[]*NodeGroup]

type NodeGroupArrayInput

type NodeGroupArrayInput interface {
	pulumi.Input

	ToNodeGroupArrayOutput() NodeGroupArrayOutput
	ToNodeGroupArrayOutputWithContext(context.Context) NodeGroupArrayOutput
}

NodeGroupArrayInput is an input type that accepts NodeGroupArray and NodeGroupArrayOutput values. You can construct a concrete instance of `NodeGroupArrayInput` via:

NodeGroupArray{ NodeGroupArgs{...} }

type NodeGroupArrayOutput

type NodeGroupArrayOutput struct{ *pulumi.OutputState }

func (NodeGroupArrayOutput) ElementType

func (NodeGroupArrayOutput) ElementType() reflect.Type

func (NodeGroupArrayOutput) Index

func (NodeGroupArrayOutput) ToNodeGroupArrayOutput

func (o NodeGroupArrayOutput) ToNodeGroupArrayOutput() NodeGroupArrayOutput

func (NodeGroupArrayOutput) ToNodeGroupArrayOutputWithContext

func (o NodeGroupArrayOutput) ToNodeGroupArrayOutputWithContext(ctx context.Context) NodeGroupArrayOutput

func (NodeGroupArrayOutput) ToOutput

type NodeGroupData

type NodeGroupData struct {
	// The AutoScalingGroup name for the node group.
	AutoScalingGroupName string `pulumi:"autoScalingGroupName"`
	// The CloudFormation Stack which defines the Node AutoScalingGroup.
	CfnStack *cloudformation.Stack `pulumi:"cfnStack"`
	// The additional security groups for the node group that captures user-specific rules.
	ExtraNodeSecurityGroups []*ec2.SecurityGroup `pulumi:"extraNodeSecurityGroups"`
	// The security group for the node group to communicate with the cluster.
	NodeSecurityGroup *ec2.SecurityGroup `pulumi:"nodeSecurityGroup"`
}

NodeGroupData describes the resources created for the given NodeGroup.

type NodeGroupDataOutput

type NodeGroupDataOutput struct{ *pulumi.OutputState }

NodeGroupData describes the resources created for the given NodeGroup.

func (NodeGroupDataOutput) AutoScalingGroupName

func (o NodeGroupDataOutput) AutoScalingGroupName() pulumi.StringOutput

The AutoScalingGroup name for the node group.

func (NodeGroupDataOutput) CfnStack

The CloudFormation Stack which defines the Node AutoScalingGroup.

func (NodeGroupDataOutput) ElementType

func (NodeGroupDataOutput) ElementType() reflect.Type

func (NodeGroupDataOutput) ExtraNodeSecurityGroups

func (o NodeGroupDataOutput) ExtraNodeSecurityGroups() ec2.SecurityGroupArrayOutput

The additional security groups for the node group that captures user-specific rules.

func (NodeGroupDataOutput) NodeSecurityGroup

func (o NodeGroupDataOutput) NodeSecurityGroup() ec2.SecurityGroupOutput

The security group for the node group to communicate with the cluster.

func (NodeGroupDataOutput) ToNodeGroupDataOutput

func (o NodeGroupDataOutput) ToNodeGroupDataOutput() NodeGroupDataOutput

func (NodeGroupDataOutput) ToNodeGroupDataOutputWithContext

func (o NodeGroupDataOutput) ToNodeGroupDataOutputWithContext(ctx context.Context) NodeGroupDataOutput

func (NodeGroupDataOutput) ToOutput

type NodeGroupDataPtrOutput

type NodeGroupDataPtrOutput struct{ *pulumi.OutputState }

func (NodeGroupDataPtrOutput) AutoScalingGroupName

func (o NodeGroupDataPtrOutput) AutoScalingGroupName() pulumi.StringPtrOutput

The AutoScalingGroup name for the node group.

func (NodeGroupDataPtrOutput) CfnStack

The CloudFormation Stack which defines the Node AutoScalingGroup.

func (NodeGroupDataPtrOutput) Elem

func (NodeGroupDataPtrOutput) ElementType

func (NodeGroupDataPtrOutput) ElementType() reflect.Type

func (NodeGroupDataPtrOutput) ExtraNodeSecurityGroups

func (o NodeGroupDataPtrOutput) ExtraNodeSecurityGroups() ec2.SecurityGroupArrayOutput

The additional security groups for the node group that captures user-specific rules.

func (NodeGroupDataPtrOutput) NodeSecurityGroup

func (o NodeGroupDataPtrOutput) NodeSecurityGroup() ec2.SecurityGroupOutput

The security group for the node group to communicate with the cluster.

func (NodeGroupDataPtrOutput) ToNodeGroupDataPtrOutput

func (o NodeGroupDataPtrOutput) ToNodeGroupDataPtrOutput() NodeGroupDataPtrOutput

func (NodeGroupDataPtrOutput) ToNodeGroupDataPtrOutputWithContext

func (o NodeGroupDataPtrOutput) ToNodeGroupDataPtrOutputWithContext(ctx context.Context) NodeGroupDataPtrOutput

func (NodeGroupDataPtrOutput) ToOutput

type NodeGroupInput

type NodeGroupInput interface {
	pulumi.Input

	ToNodeGroupOutput() NodeGroupOutput
	ToNodeGroupOutputWithContext(ctx context.Context) NodeGroupOutput
}

type NodeGroupMap

type NodeGroupMap map[string]NodeGroupInput

func (NodeGroupMap) ElementType

func (NodeGroupMap) ElementType() reflect.Type

func (NodeGroupMap) ToNodeGroupMapOutput

func (i NodeGroupMap) ToNodeGroupMapOutput() NodeGroupMapOutput

func (NodeGroupMap) ToNodeGroupMapOutputWithContext

func (i NodeGroupMap) ToNodeGroupMapOutputWithContext(ctx context.Context) NodeGroupMapOutput

func (NodeGroupMap) ToOutput

func (i NodeGroupMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*NodeGroup]

type NodeGroupMapInput

type NodeGroupMapInput interface {
	pulumi.Input

	ToNodeGroupMapOutput() NodeGroupMapOutput
	ToNodeGroupMapOutputWithContext(context.Context) NodeGroupMapOutput
}

NodeGroupMapInput is an input type that accepts NodeGroupMap and NodeGroupMapOutput values. You can construct a concrete instance of `NodeGroupMapInput` via:

NodeGroupMap{ "key": NodeGroupArgs{...} }

type NodeGroupMapOutput

type NodeGroupMapOutput struct{ *pulumi.OutputState }

func (NodeGroupMapOutput) ElementType

func (NodeGroupMapOutput) ElementType() reflect.Type

func (NodeGroupMapOutput) MapIndex

func (NodeGroupMapOutput) ToNodeGroupMapOutput

func (o NodeGroupMapOutput) ToNodeGroupMapOutput() NodeGroupMapOutput

func (NodeGroupMapOutput) ToNodeGroupMapOutputWithContext

func (o NodeGroupMapOutput) ToNodeGroupMapOutputWithContext(ctx context.Context) NodeGroupMapOutput

func (NodeGroupMapOutput) ToOutput

type NodeGroupOutput

type NodeGroupOutput struct{ *pulumi.OutputState }

func (NodeGroupOutput) AutoScalingGroupName

func (o NodeGroupOutput) AutoScalingGroupName() pulumi.StringOutput

The AutoScalingGroup name for the Node group.

func (NodeGroupOutput) CfnStack

The CloudFormation Stack which defines the Node AutoScalingGroup.

func (NodeGroupOutput) ElementType

func (NodeGroupOutput) ElementType() reflect.Type

func (NodeGroupOutput) ExtraNodeSecurityGroups

func (o NodeGroupOutput) ExtraNodeSecurityGroups() ec2.SecurityGroupArrayOutput

The additional security groups for the node group that captures user-specific rules.

func (NodeGroupOutput) NodeSecurityGroup

func (o NodeGroupOutput) NodeSecurityGroup() ec2.SecurityGroupOutput

The security group for the node group to communicate with the cluster.

func (NodeGroupOutput) ToNodeGroupOutput

func (o NodeGroupOutput) ToNodeGroupOutput() NodeGroupOutput

func (NodeGroupOutput) ToNodeGroupOutputWithContext

func (o NodeGroupOutput) ToNodeGroupOutputWithContext(ctx context.Context) NodeGroupOutput

func (NodeGroupOutput) ToOutput

type NodeGroupSecurityGroup

type NodeGroupSecurityGroup struct {
	pulumi.ResourceState

	// The security group for node groups with the default ingress & egress rules required to connect and work with the EKS cluster security group.
	SecurityGroup ec2.SecurityGroupOutput `pulumi:"securityGroup"`
	// The EKS cluster ingress rule.
	SecurityGroupRule ec2.SecurityGroupRuleOutput `pulumi:"securityGroupRule"`
}

NodeGroupSecurityGroup is a component that wraps creating a security group for node groups with the default ingress & egress rules required to connect and work with the EKS cluster security group.

func NewNodeGroupSecurityGroup

func NewNodeGroupSecurityGroup(ctx *pulumi.Context,
	name string, args *NodeGroupSecurityGroupArgs, opts ...pulumi.ResourceOption) (*NodeGroupSecurityGroup, error)

NewNodeGroupSecurityGroup registers a new resource with the given unique name, arguments, and options.

func (*NodeGroupSecurityGroup) ElementType

func (*NodeGroupSecurityGroup) ElementType() reflect.Type

func (*NodeGroupSecurityGroup) ToNodeGroupSecurityGroupOutput

func (i *NodeGroupSecurityGroup) ToNodeGroupSecurityGroupOutput() NodeGroupSecurityGroupOutput

func (*NodeGroupSecurityGroup) ToNodeGroupSecurityGroupOutputWithContext

func (i *NodeGroupSecurityGroup) ToNodeGroupSecurityGroupOutputWithContext(ctx context.Context) NodeGroupSecurityGroupOutput

func (*NodeGroupSecurityGroup) ToOutput

type NodeGroupSecurityGroupArgs

type NodeGroupSecurityGroupArgs struct {
	// The security group associated with the EKS cluster.
	ClusterSecurityGroup ec2.SecurityGroupInput
	// The EKS cluster associated with the worker node group
	EksCluster eks.ClusterInput
	// Key-value mapping of tags to apply to this security group.
	Tags pulumi.StringMapInput
	// The VPC in which to create the worker node group.
	VpcId pulumi.StringInput
}

The set of arguments for constructing a NodeGroupSecurityGroup resource.

func (NodeGroupSecurityGroupArgs) ElementType

func (NodeGroupSecurityGroupArgs) ElementType() reflect.Type

type NodeGroupSecurityGroupArray

type NodeGroupSecurityGroupArray []NodeGroupSecurityGroupInput

func (NodeGroupSecurityGroupArray) ElementType

func (NodeGroupSecurityGroupArray) ToNodeGroupSecurityGroupArrayOutput

func (i NodeGroupSecurityGroupArray) ToNodeGroupSecurityGroupArrayOutput() NodeGroupSecurityGroupArrayOutput

func (NodeGroupSecurityGroupArray) ToNodeGroupSecurityGroupArrayOutputWithContext

func (i NodeGroupSecurityGroupArray) ToNodeGroupSecurityGroupArrayOutputWithContext(ctx context.Context) NodeGroupSecurityGroupArrayOutput

func (NodeGroupSecurityGroupArray) ToOutput

type NodeGroupSecurityGroupArrayInput

type NodeGroupSecurityGroupArrayInput interface {
	pulumi.Input

	ToNodeGroupSecurityGroupArrayOutput() NodeGroupSecurityGroupArrayOutput
	ToNodeGroupSecurityGroupArrayOutputWithContext(context.Context) NodeGroupSecurityGroupArrayOutput
}

NodeGroupSecurityGroupArrayInput is an input type that accepts NodeGroupSecurityGroupArray and NodeGroupSecurityGroupArrayOutput values. You can construct a concrete instance of `NodeGroupSecurityGroupArrayInput` via:

NodeGroupSecurityGroupArray{ NodeGroupSecurityGroupArgs{...} }

type NodeGroupSecurityGroupArrayOutput

type NodeGroupSecurityGroupArrayOutput struct{ *pulumi.OutputState }

func (NodeGroupSecurityGroupArrayOutput) ElementType

func (NodeGroupSecurityGroupArrayOutput) Index

func (NodeGroupSecurityGroupArrayOutput) ToNodeGroupSecurityGroupArrayOutput

func (o NodeGroupSecurityGroupArrayOutput) ToNodeGroupSecurityGroupArrayOutput() NodeGroupSecurityGroupArrayOutput

func (NodeGroupSecurityGroupArrayOutput) ToNodeGroupSecurityGroupArrayOutputWithContext

func (o NodeGroupSecurityGroupArrayOutput) ToNodeGroupSecurityGroupArrayOutputWithContext(ctx context.Context) NodeGroupSecurityGroupArrayOutput

func (NodeGroupSecurityGroupArrayOutput) ToOutput

type NodeGroupSecurityGroupInput

type NodeGroupSecurityGroupInput interface {
	pulumi.Input

	ToNodeGroupSecurityGroupOutput() NodeGroupSecurityGroupOutput
	ToNodeGroupSecurityGroupOutputWithContext(ctx context.Context) NodeGroupSecurityGroupOutput
}

type NodeGroupSecurityGroupMap

type NodeGroupSecurityGroupMap map[string]NodeGroupSecurityGroupInput

func (NodeGroupSecurityGroupMap) ElementType

func (NodeGroupSecurityGroupMap) ElementType() reflect.Type

func (NodeGroupSecurityGroupMap) ToNodeGroupSecurityGroupMapOutput

func (i NodeGroupSecurityGroupMap) ToNodeGroupSecurityGroupMapOutput() NodeGroupSecurityGroupMapOutput

func (NodeGroupSecurityGroupMap) ToNodeGroupSecurityGroupMapOutputWithContext

func (i NodeGroupSecurityGroupMap) ToNodeGroupSecurityGroupMapOutputWithContext(ctx context.Context) NodeGroupSecurityGroupMapOutput

func (NodeGroupSecurityGroupMap) ToOutput

type NodeGroupSecurityGroupMapInput

type NodeGroupSecurityGroupMapInput interface {
	pulumi.Input

	ToNodeGroupSecurityGroupMapOutput() NodeGroupSecurityGroupMapOutput
	ToNodeGroupSecurityGroupMapOutputWithContext(context.Context) NodeGroupSecurityGroupMapOutput
}

NodeGroupSecurityGroupMapInput is an input type that accepts NodeGroupSecurityGroupMap and NodeGroupSecurityGroupMapOutput values. You can construct a concrete instance of `NodeGroupSecurityGroupMapInput` via:

NodeGroupSecurityGroupMap{ "key": NodeGroupSecurityGroupArgs{...} }

type NodeGroupSecurityGroupMapOutput

type NodeGroupSecurityGroupMapOutput struct{ *pulumi.OutputState }

func (NodeGroupSecurityGroupMapOutput) ElementType

func (NodeGroupSecurityGroupMapOutput) MapIndex

func (NodeGroupSecurityGroupMapOutput) ToNodeGroupSecurityGroupMapOutput

func (o NodeGroupSecurityGroupMapOutput) ToNodeGroupSecurityGroupMapOutput() NodeGroupSecurityGroupMapOutput

func (NodeGroupSecurityGroupMapOutput) ToNodeGroupSecurityGroupMapOutputWithContext

func (o NodeGroupSecurityGroupMapOutput) ToNodeGroupSecurityGroupMapOutputWithContext(ctx context.Context) NodeGroupSecurityGroupMapOutput

func (NodeGroupSecurityGroupMapOutput) ToOutput

type NodeGroupSecurityGroupOutput

type NodeGroupSecurityGroupOutput struct{ *pulumi.OutputState }

func (NodeGroupSecurityGroupOutput) ElementType

func (NodeGroupSecurityGroupOutput) SecurityGroup

The security group for node groups with the default ingress & egress rules required to connect and work with the EKS cluster security group.

func (NodeGroupSecurityGroupOutput) SecurityGroupRule

The EKS cluster ingress rule.

func (NodeGroupSecurityGroupOutput) ToNodeGroupSecurityGroupOutput

func (o NodeGroupSecurityGroupOutput) ToNodeGroupSecurityGroupOutput() NodeGroupSecurityGroupOutput

func (NodeGroupSecurityGroupOutput) ToNodeGroupSecurityGroupOutputWithContext

func (o NodeGroupSecurityGroupOutput) ToNodeGroupSecurityGroupOutputWithContext(ctx context.Context) NodeGroupSecurityGroupOutput

func (NodeGroupSecurityGroupOutput) ToOutput

type NodeGroupV2

type NodeGroupV2 struct {
	pulumi.ResourceState

	// The AutoScalingGroup for the Node group.
	AutoScalingGroup autoscaling.GroupOutput `pulumi:"autoScalingGroup"`
	// The additional security groups for the node group that captures user-specific rules.
	ExtraNodeSecurityGroups ec2.SecurityGroupArrayOutput `pulumi:"extraNodeSecurityGroups"`
	// The security group for the node group to communicate with the cluster.
	NodeSecurityGroup ec2.SecurityGroupOutput `pulumi:"nodeSecurityGroup"`
}

NodeGroup is a component that wraps the AWS EC2 instances that provide compute capacity for an EKS cluster.

func NewNodeGroupV2

func NewNodeGroupV2(ctx *pulumi.Context,
	name string, args *NodeGroupV2Args, opts ...pulumi.ResourceOption) (*NodeGroupV2, error)

NewNodeGroupV2 registers a new resource with the given unique name, arguments, and options.

func (*NodeGroupV2) ElementType

func (*NodeGroupV2) ElementType() reflect.Type

func (*NodeGroupV2) ToNodeGroupV2Output

func (i *NodeGroupV2) ToNodeGroupV2Output() NodeGroupV2Output

func (*NodeGroupV2) ToNodeGroupV2OutputWithContext

func (i *NodeGroupV2) ToNodeGroupV2OutputWithContext(ctx context.Context) NodeGroupV2Output

func (*NodeGroupV2) ToOutput

func (i *NodeGroupV2) ToOutput(ctx context.Context) pulumix.Output[*NodeGroupV2]

type NodeGroupV2Args

type NodeGroupV2Args struct {
	// The AMI ID to use for the worker nodes.
	//
	// Defaults to the latest recommended EKS Optimized Linux AMI from the AWS Systems Manager Parameter Store.
	//
	// Note: `amiId` and `gpu` are mutually exclusive.
	//
	// See for more details:
	// - https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html.
	AmiId pulumi.StringPtrInput
	// The AMI Type to use for the worker nodes.
	//
	// Only applicable when setting an AMI ID that is of type `arm64`.
	//
	// Note: `amiType` and `gpu` are mutually exclusive.
	AmiType pulumi.StringPtrInput
	// The tags to apply to the NodeGroup's AutoScalingGroup in the CloudFormation Stack.
	//
	// Per AWS, all stack-level tags, including automatically created tags, and the `cloudFormationTags` option are propagated to resources that AWS CloudFormation supports, including the AutoScalingGroup. See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-resource-tags.html
	//
	// Note: Given the inheritance of auto-generated CF tags and `cloudFormationTags`, you should either supply the tag in `autoScalingGroupTags` or `cloudFormationTags`, but not both.
	AutoScalingGroupTags pulumi.StringMapInput
	// Additional args to pass directly to `/etc/eks/bootstrap.sh`. For details on available options, see: https://github.com/awslabs/amazon-eks-ami/blob/master/files/bootstrap.sh. Note that the `--apiserver-endpoint`, `--b64-cluster-ca` and `--kubelet-extra-args` flags are included automatically based on other configuration parameters.
	BootstrapExtraArgs *string
	// The tags to apply to the CloudFormation Stack of the Worker NodeGroup.
	//
	// Note: Given the inheritance of auto-generated CF tags and `cloudFormationTags`, you should either supply the tag in `autoScalingGroupTags` or `cloudFormationTags`, but not both.
	CloudFormationTags pulumi.StringMapInput
	// The target EKS cluster.
	Cluster pulumi.Input
	// The ingress rule that gives node group access.
	ClusterIngressRule ec2.SecurityGroupRuleInput
	// The number of worker nodes that should be running in the cluster. Defaults to 2.
	DesiredCapacity pulumi.IntPtrInput
	// Encrypt the root block device of the nodes in the node group.
	EncryptRootBlockDevice pulumi.BoolPtrInput
	// Extra security groups to attach on all nodes in this worker node group.
	//
	// This additional set of security groups captures any user application rules that will be needed for the nodes.
	ExtraNodeSecurityGroups ec2.SecurityGroupArrayInput
	// Use the latest recommended EKS Optimized Linux AMI with GPU support for the worker nodes from the AWS Systems Manager Parameter Store.
	//
	// Defaults to false.
	//
	// Note: `gpu` and `amiId` are mutually exclusive.
	//
	// See for more details:
	// - https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html
	// - https://docs.aws.amazon.com/eks/latest/userguide/retrieve-ami-id.html
	Gpu pulumi.BoolPtrInput
	// The ingress rule that gives node group access.
	InstanceProfile *iam.InstanceProfile
	// The instance type to use for the cluster's nodes. Defaults to "t2.medium".
	InstanceType pulumi.StringPtrInput
	// Name of the key pair to use for SSH access to worker nodes.
	KeyName pulumi.StringPtrInput
	// Extra args to pass to the Kubelet. Corresponds to the options passed in the `--kubeletExtraArgs` flag to `/etc/eks/bootstrap.sh`. For example, '--port=10251 --address=0.0.0.0'. Note that the `labels` and `taints` properties will be applied to this list (using `--node-labels` and `--register-with-taints` respectively) after to the explicit `kubeletExtraArgs`.
	KubeletExtraArgs *string
	// Custom k8s node labels to be attached to each worker node. Adds the given key/value pairs to the `--node-labels` kubelet argument.
	Labels map[string]string
	// The tag specifications to apply to the launch template.
	LaunchTemplateTagSpecifications ec2.LaunchTemplateTagSpecificationArrayInput
	// The maximum number of worker nodes running in the cluster. Defaults to 2.
	MaxSize pulumi.IntPtrInput
	// The minimum amount of instances that should remain available during an instance refresh, expressed as a percentage. Defaults to 50.
	MinRefreshPercentage pulumi.IntPtrInput
	// The minimum number of worker nodes running in the cluster. Defaults to 1.
	MinSize pulumi.IntPtrInput
	// Whether or not to auto-assign public IP addresses on the EKS worker nodes. If this toggle is set to true, the EKS workers will be auto-assigned public IPs. If false, they will not be auto-assigned public IPs.
	NodeAssociatePublicIpAddress *bool
	// Public key material for SSH access to worker nodes. See allowed formats at:
	// https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html
	// If not provided, no SSH access is enabled on VMs.
	NodePublicKey pulumi.StringPtrInput
	// The size in GiB of a cluster node's root volume. Defaults to 20.
	NodeRootVolumeSize pulumi.IntPtrInput
	// The security group for the worker node group to communicate with the cluster.
	//
	// This security group requires specific inbound and outbound rules.
	//
	// See for more details:
	// https://docs.aws.amazon.com/eks/latest/userguide/sec-group-reqs.html
	//
	// Note: The `nodeSecurityGroup` option and the cluster option`nodeSecurityGroupTags` are mutually exclusive.
	NodeSecurityGroup ec2.SecurityGroupInput
	// The set of subnets to override and use for the worker node group.
	//
	// Setting this option overrides which subnets to use for the worker node group, regardless if the cluster's `subnetIds` is set, or if `publicSubnetIds` and/or `privateSubnetIds` were set.
	NodeSubnetIds pulumi.StringArrayInput
	// Extra code to run on node startup. This code will run after the AWS EKS bootstrapping code and before the node signals its readiness to the managing CloudFormation stack. This code must be a typical user data script: critically it must begin with an interpreter directive (i.e. a `#!`).
	NodeUserData pulumi.StringPtrInput
	// User specified code to run on node startup. This code is expected to handle the full AWS EKS bootstrapping code and signal node readiness to the managing CloudFormation stack. This code must be a complete and executable user data script in bash (Linux) or powershell (Windows).
	//
	// See for more details: https://docs.aws.amazon.com/eks/latest/userguide/worker.html
	NodeUserDataOverride pulumi.StringPtrInput
	// Bidding price for spot instance. If set, only spot instances will be added as worker node.
	SpotPrice pulumi.StringPtrInput
	// Custom k8s node taints to be attached to each worker node. Adds the given taints to the `--register-with-taints` kubelet argument
	Taints map[string]TaintArgs
	// Desired Kubernetes master / control plane version. If you do not specify a value, the latest available version is used.
	Version pulumi.StringPtrInput
}

The set of arguments for constructing a NodeGroupV2 resource.

func (NodeGroupV2Args) ElementType

func (NodeGroupV2Args) ElementType() reflect.Type

type NodeGroupV2Array

type NodeGroupV2Array []NodeGroupV2Input

func (NodeGroupV2Array) ElementType

func (NodeGroupV2Array) ElementType() reflect.Type

func (NodeGroupV2Array) ToNodeGroupV2ArrayOutput

func (i NodeGroupV2Array) ToNodeGroupV2ArrayOutput() NodeGroupV2ArrayOutput

func (NodeGroupV2Array) ToNodeGroupV2ArrayOutputWithContext

func (i NodeGroupV2Array) ToNodeGroupV2ArrayOutputWithContext(ctx context.Context) NodeGroupV2ArrayOutput

func (NodeGroupV2Array) ToOutput

type NodeGroupV2ArrayInput

type NodeGroupV2ArrayInput interface {
	pulumi.Input

	ToNodeGroupV2ArrayOutput() NodeGroupV2ArrayOutput
	ToNodeGroupV2ArrayOutputWithContext(context.Context) NodeGroupV2ArrayOutput
}

NodeGroupV2ArrayInput is an input type that accepts NodeGroupV2Array and NodeGroupV2ArrayOutput values. You can construct a concrete instance of `NodeGroupV2ArrayInput` via:

NodeGroupV2Array{ NodeGroupV2Args{...} }

type NodeGroupV2ArrayOutput

type NodeGroupV2ArrayOutput struct{ *pulumi.OutputState }

func (NodeGroupV2ArrayOutput) ElementType

func (NodeGroupV2ArrayOutput) ElementType() reflect.Type

func (NodeGroupV2ArrayOutput) Index

func (NodeGroupV2ArrayOutput) ToNodeGroupV2ArrayOutput

func (o NodeGroupV2ArrayOutput) ToNodeGroupV2ArrayOutput() NodeGroupV2ArrayOutput

func (NodeGroupV2ArrayOutput) ToNodeGroupV2ArrayOutputWithContext

func (o NodeGroupV2ArrayOutput) ToNodeGroupV2ArrayOutputWithContext(ctx context.Context) NodeGroupV2ArrayOutput

func (NodeGroupV2ArrayOutput) ToOutput

type NodeGroupV2Input

type NodeGroupV2Input interface {
	pulumi.Input

	ToNodeGroupV2Output() NodeGroupV2Output
	ToNodeGroupV2OutputWithContext(ctx context.Context) NodeGroupV2Output
}

type NodeGroupV2Map

type NodeGroupV2Map map[string]NodeGroupV2Input

func (NodeGroupV2Map) ElementType

func (NodeGroupV2Map) ElementType() reflect.Type

func (NodeGroupV2Map) ToNodeGroupV2MapOutput

func (i NodeGroupV2Map) ToNodeGroupV2MapOutput() NodeGroupV2MapOutput

func (NodeGroupV2Map) ToNodeGroupV2MapOutputWithContext

func (i NodeGroupV2Map) ToNodeGroupV2MapOutputWithContext(ctx context.Context) NodeGroupV2MapOutput

func (NodeGroupV2Map) ToOutput

type NodeGroupV2MapInput

type NodeGroupV2MapInput interface {
	pulumi.Input

	ToNodeGroupV2MapOutput() NodeGroupV2MapOutput
	ToNodeGroupV2MapOutputWithContext(context.Context) NodeGroupV2MapOutput
}

NodeGroupV2MapInput is an input type that accepts NodeGroupV2Map and NodeGroupV2MapOutput values. You can construct a concrete instance of `NodeGroupV2MapInput` via:

NodeGroupV2Map{ "key": NodeGroupV2Args{...} }

type NodeGroupV2MapOutput

type NodeGroupV2MapOutput struct{ *pulumi.OutputState }

func (NodeGroupV2MapOutput) ElementType

func (NodeGroupV2MapOutput) ElementType() reflect.Type

func (NodeGroupV2MapOutput) MapIndex

func (NodeGroupV2MapOutput) ToNodeGroupV2MapOutput

func (o NodeGroupV2MapOutput) ToNodeGroupV2MapOutput() NodeGroupV2MapOutput

func (NodeGroupV2MapOutput) ToNodeGroupV2MapOutputWithContext

func (o NodeGroupV2MapOutput) ToNodeGroupV2MapOutputWithContext(ctx context.Context) NodeGroupV2MapOutput

func (NodeGroupV2MapOutput) ToOutput

type NodeGroupV2Output

type NodeGroupV2Output struct{ *pulumi.OutputState }

func (NodeGroupV2Output) AutoScalingGroup

func (o NodeGroupV2Output) AutoScalingGroup() autoscaling.GroupOutput

The AutoScalingGroup for the Node group.

func (NodeGroupV2Output) ElementType

func (NodeGroupV2Output) ElementType() reflect.Type

func (NodeGroupV2Output) ExtraNodeSecurityGroups

func (o NodeGroupV2Output) ExtraNodeSecurityGroups() ec2.SecurityGroupArrayOutput

The additional security groups for the node group that captures user-specific rules.

func (NodeGroupV2Output) NodeSecurityGroup

func (o NodeGroupV2Output) NodeSecurityGroup() ec2.SecurityGroupOutput

The security group for the node group to communicate with the cluster.

func (NodeGroupV2Output) ToNodeGroupV2Output

func (o NodeGroupV2Output) ToNodeGroupV2Output() NodeGroupV2Output

func (NodeGroupV2Output) ToNodeGroupV2OutputWithContext

func (o NodeGroupV2Output) ToNodeGroupV2OutputWithContext(ctx context.Context) NodeGroupV2Output

func (NodeGroupV2Output) ToOutput

type Provider

type Provider struct {
	pulumi.ProviderResourceState
}

func NewProvider

func NewProvider(ctx *pulumi.Context,
	name string, args *ProviderArgs, opts ...pulumi.ResourceOption) (*Provider, error)

NewProvider registers a new resource with the given unique name, arguments, and options.

func (*Provider) ElementType

func (*Provider) ElementType() reflect.Type

func (*Provider) ToOutput

func (i *Provider) ToOutput(ctx context.Context) pulumix.Output[*Provider]

func (*Provider) ToProviderOutput

func (i *Provider) ToProviderOutput() ProviderOutput

func (*Provider) ToProviderOutputWithContext

func (i *Provider) ToProviderOutputWithContext(ctx context.Context) ProviderOutput

type ProviderArgs

type ProviderArgs struct {
}

The set of arguments for constructing a Provider resource.

func (ProviderArgs) ElementType

func (ProviderArgs) ElementType() reflect.Type

type ProviderInput

type ProviderInput interface {
	pulumi.Input

	ToProviderOutput() ProviderOutput
	ToProviderOutputWithContext(ctx context.Context) ProviderOutput
}

type ProviderOutput

type ProviderOutput struct{ *pulumi.OutputState }

func (ProviderOutput) ElementType

func (ProviderOutput) ElementType() reflect.Type

func (ProviderOutput) ToOutput

func (ProviderOutput) ToProviderOutput

func (o ProviderOutput) ToProviderOutput() ProviderOutput

func (ProviderOutput) ToProviderOutputWithContext

func (o ProviderOutput) ToProviderOutputWithContext(ctx context.Context) ProviderOutput

type RoleMapping

type RoleMapping struct {
	// A list of groups within Kubernetes to which the role is mapped.
	Groups []string `pulumi:"groups"`
	// The ARN of the IAM role to add.
	RoleArn string `pulumi:"roleArn"`
	// The user name within Kubernetes to map to the IAM role. By default, the user name is the ARN of the IAM role.
	Username string `pulumi:"username"`
}

Describes a mapping from an AWS IAM role to a Kubernetes user and groups.

type RoleMappingArgs

type RoleMappingArgs struct {
	// A list of groups within Kubernetes to which the role is mapped.
	Groups pulumi.StringArrayInput `pulumi:"groups"`
	// The ARN of the IAM role to add.
	RoleArn pulumi.StringInput `pulumi:"roleArn"`
	// The user name within Kubernetes to map to the IAM role. By default, the user name is the ARN of the IAM role.
	Username pulumi.StringInput `pulumi:"username"`
}

Describes a mapping from an AWS IAM role to a Kubernetes user and groups.

func (RoleMappingArgs) ElementType

func (RoleMappingArgs) ElementType() reflect.Type

func (RoleMappingArgs) ToOutput

func (RoleMappingArgs) ToRoleMappingOutput

func (i RoleMappingArgs) ToRoleMappingOutput() RoleMappingOutput

func (RoleMappingArgs) ToRoleMappingOutputWithContext

func (i RoleMappingArgs) ToRoleMappingOutputWithContext(ctx context.Context) RoleMappingOutput

type RoleMappingArray

type RoleMappingArray []RoleMappingInput

func (RoleMappingArray) ElementType

func (RoleMappingArray) ElementType() reflect.Type

func (RoleMappingArray) ToOutput

func (RoleMappingArray) ToRoleMappingArrayOutput

func (i RoleMappingArray) ToRoleMappingArrayOutput() RoleMappingArrayOutput

func (RoleMappingArray) ToRoleMappingArrayOutputWithContext

func (i RoleMappingArray) ToRoleMappingArrayOutputWithContext(ctx context.Context) RoleMappingArrayOutput

type RoleMappingArrayInput

type RoleMappingArrayInput interface {
	pulumi.Input

	ToRoleMappingArrayOutput() RoleMappingArrayOutput
	ToRoleMappingArrayOutputWithContext(context.Context) RoleMappingArrayOutput
}

RoleMappingArrayInput is an input type that accepts RoleMappingArray and RoleMappingArrayOutput values. You can construct a concrete instance of `RoleMappingArrayInput` via:

RoleMappingArray{ RoleMappingArgs{...} }

type RoleMappingArrayOutput

type RoleMappingArrayOutput struct{ *pulumi.OutputState }

func (RoleMappingArrayOutput) ElementType

func (RoleMappingArrayOutput) ElementType() reflect.Type

func (RoleMappingArrayOutput) Index

func (RoleMappingArrayOutput) ToOutput

func (RoleMappingArrayOutput) ToRoleMappingArrayOutput

func (o RoleMappingArrayOutput) ToRoleMappingArrayOutput() RoleMappingArrayOutput

func (RoleMappingArrayOutput) ToRoleMappingArrayOutputWithContext

func (o RoleMappingArrayOutput) ToRoleMappingArrayOutputWithContext(ctx context.Context) RoleMappingArrayOutput

type RoleMappingInput

type RoleMappingInput interface {
	pulumi.Input

	ToRoleMappingOutput() RoleMappingOutput
	ToRoleMappingOutputWithContext(context.Context) RoleMappingOutput
}

RoleMappingInput is an input type that accepts RoleMappingArgs and RoleMappingOutput values. You can construct a concrete instance of `RoleMappingInput` via:

RoleMappingArgs{...}

type RoleMappingOutput

type RoleMappingOutput struct{ *pulumi.OutputState }

Describes a mapping from an AWS IAM role to a Kubernetes user and groups.

func (RoleMappingOutput) ElementType

func (RoleMappingOutput) ElementType() reflect.Type

func (RoleMappingOutput) Groups

A list of groups within Kubernetes to which the role is mapped.

func (RoleMappingOutput) RoleArn

The ARN of the IAM role to add.

func (RoleMappingOutput) ToOutput

func (RoleMappingOutput) ToRoleMappingOutput

func (o RoleMappingOutput) ToRoleMappingOutput() RoleMappingOutput

func (RoleMappingOutput) ToRoleMappingOutputWithContext

func (o RoleMappingOutput) ToRoleMappingOutputWithContext(ctx context.Context) RoleMappingOutput

func (RoleMappingOutput) Username

func (o RoleMappingOutput) Username() pulumi.StringOutput

The user name within Kubernetes to map to the IAM role. By default, the user name is the ARN of the IAM role.

type StorageClass

type StorageClass struct {
	// AllowVolumeExpansion shows whether the storage class allow volume expand.
	AllowVolumeExpansion *bool `pulumi:"allowVolumeExpansion"`
	// True if this storage class should be a default storage class for the cluster.
	//
	// Note: As of Kubernetes v1.11+ on EKS, a default `gp2` storage class will always be created automatically for the cluster by the EKS service. See https://docs.aws.amazon.com/eks/latest/userguide/storage-classes.html
	//
	// Please note that at most one storage class can be marked as default. If two or more of them are marked as default, a PersistentVolumeClaim without `storageClassName` explicitly specified cannot be created. See: https://kubernetes.io/docs/tasks/administer-cluster/change-default-storage-class/#changing-the-default-storageclass
	Default *bool `pulumi:"default"`
	// Denotes whether the EBS volume should be encrypted.
	Encrypted *bool `pulumi:"encrypted"`
	// I/O operations per second per GiB for "io1" volumes. The AWS volume plugin multiplies this with the size of a requested volume to compute IOPS of the volume and caps the result at 20,000 IOPS.
	IopsPerGb *int `pulumi:"iopsPerGb"`
	// The full Amazon Resource Name of the key to use when encrypting the volume. If none is supplied but encrypted is true, a key is generated by AWS.
	KmsKeyId *string `pulumi:"kmsKeyId"`
	// Standard object's metadata. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata
	Metadata *metav1.ObjectMeta `pulumi:"metadata"`
	// Dynamically provisioned PersistentVolumes of this storage class are created with these mountOptions, e.g. ["ro", "soft"]. Not validated - mount of the PVs will simply fail if one is invalid.
	MountOptions []string `pulumi:"mountOptions"`
	// Dynamically provisioned PersistentVolumes of this storage class are created with this reclaimPolicy. Defaults to Delete.
	ReclaimPolicy *string `pulumi:"reclaimPolicy"`
	// The EBS volume type.
	Type string `pulumi:"type"`
	// VolumeBindingMode indicates how PersistentVolumeClaims should be provisioned and bound. When unset, VolumeBindingImmediate is used. This field is alpha-level and is only honored by servers that enable the VolumeScheduling feature.
	VolumeBindingMode *string `pulumi:"volumeBindingMode"`
	// The AWS zone or zones for the EBS volume. If zones is not specified, volumes are generally round-robin-ed across all active zones where Kubernetes cluster has a node. zone and zones parameters must not be used at the same time.
	Zones []string `pulumi:"zones"`
}

StorageClass describes the inputs to a single Kubernetes StorageClass provisioned by AWS. Any number of storage classes can be added to a cluster at creation time. One of these storage classes may be configured the default storage class for the cluster.

type Taint

type Taint struct {
	// The effect of the taint.
	Effect string `pulumi:"effect"`
	// The value of the taint.
	Value string `pulumi:"value"`
}

Represents a Kubernetes `taint` to apply to all Nodes in a NodeGroup. See https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/.

type TaintArgs

type TaintArgs struct {
	// The effect of the taint.
	Effect string `pulumi:"effect"`
	// The value of the taint.
	Value string `pulumi:"value"`
}

Represents a Kubernetes `taint` to apply to all Nodes in a NodeGroup. See https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/.

func (TaintArgs) ElementType

func (TaintArgs) ElementType() reflect.Type

func (TaintArgs) ToOutput

func (i TaintArgs) ToOutput(ctx context.Context) pulumix.Output[Taint]

func (TaintArgs) ToTaintOutput

func (i TaintArgs) ToTaintOutput() TaintOutput

func (TaintArgs) ToTaintOutputWithContext

func (i TaintArgs) ToTaintOutputWithContext(ctx context.Context) TaintOutput

type TaintInput

type TaintInput interface {
	pulumi.Input

	ToTaintOutput() TaintOutput
	ToTaintOutputWithContext(context.Context) TaintOutput
}

TaintInput is an input type that accepts TaintArgs and TaintOutput values. You can construct a concrete instance of `TaintInput` via:

TaintArgs{...}

type TaintMap

type TaintMap map[string]TaintInput

func (TaintMap) ElementType

func (TaintMap) ElementType() reflect.Type

func (TaintMap) ToOutput

func (i TaintMap) ToOutput(ctx context.Context) pulumix.Output[map[string]Taint]

func (TaintMap) ToTaintMapOutput

func (i TaintMap) ToTaintMapOutput() TaintMapOutput

func (TaintMap) ToTaintMapOutputWithContext

func (i TaintMap) ToTaintMapOutputWithContext(ctx context.Context) TaintMapOutput

type TaintMapInput

type TaintMapInput interface {
	pulumi.Input

	ToTaintMapOutput() TaintMapOutput
	ToTaintMapOutputWithContext(context.Context) TaintMapOutput
}

TaintMapInput is an input type that accepts TaintMap and TaintMapOutput values. You can construct a concrete instance of `TaintMapInput` via:

TaintMap{ "key": TaintArgs{...} }

type TaintMapOutput

type TaintMapOutput struct{ *pulumi.OutputState }

func (TaintMapOutput) ElementType

func (TaintMapOutput) ElementType() reflect.Type

func (TaintMapOutput) MapIndex

func (TaintMapOutput) ToOutput

func (o TaintMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]Taint]

func (TaintMapOutput) ToTaintMapOutput

func (o TaintMapOutput) ToTaintMapOutput() TaintMapOutput

func (TaintMapOutput) ToTaintMapOutputWithContext

func (o TaintMapOutput) ToTaintMapOutputWithContext(ctx context.Context) TaintMapOutput

type TaintOutput

type TaintOutput struct{ *pulumi.OutputState }

Represents a Kubernetes `taint` to apply to all Nodes in a NodeGroup. See https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/.

func (TaintOutput) Effect

func (o TaintOutput) Effect() pulumi.StringOutput

The effect of the taint.

func (TaintOutput) ElementType

func (TaintOutput) ElementType() reflect.Type

func (TaintOutput) ToOutput

func (o TaintOutput) ToOutput(ctx context.Context) pulumix.Output[Taint]

func (TaintOutput) ToTaintOutput

func (o TaintOutput) ToTaintOutput() TaintOutput

func (TaintOutput) ToTaintOutputWithContext

func (o TaintOutput) ToTaintOutputWithContext(ctx context.Context) TaintOutput

func (TaintOutput) Value

func (o TaintOutput) Value() pulumi.StringOutput

The value of the taint.

type UserMapping

type UserMapping struct {
	// A list of groups within Kubernetes to which the user is mapped to.
	Groups []string `pulumi:"groups"`
	// The ARN of the IAM user to add.
	UserArn string `pulumi:"userArn"`
	// The user name within Kubernetes to map to the IAM user. By default, the user name is the ARN of the IAM user.
	Username string `pulumi:"username"`
}

Describes a mapping from an AWS IAM user to a Kubernetes user and groups.

type UserMappingArgs

type UserMappingArgs struct {
	// A list of groups within Kubernetes to which the user is mapped to.
	Groups pulumi.StringArrayInput `pulumi:"groups"`
	// The ARN of the IAM user to add.
	UserArn pulumi.StringInput `pulumi:"userArn"`
	// The user name within Kubernetes to map to the IAM user. By default, the user name is the ARN of the IAM user.
	Username pulumi.StringInput `pulumi:"username"`
}

Describes a mapping from an AWS IAM user to a Kubernetes user and groups.

func (UserMappingArgs) ElementType

func (UserMappingArgs) ElementType() reflect.Type

func (UserMappingArgs) ToOutput

func (UserMappingArgs) ToUserMappingOutput

func (i UserMappingArgs) ToUserMappingOutput() UserMappingOutput

func (UserMappingArgs) ToUserMappingOutputWithContext

func (i UserMappingArgs) ToUserMappingOutputWithContext(ctx context.Context) UserMappingOutput

type UserMappingArray

type UserMappingArray []UserMappingInput

func (UserMappingArray) ElementType

func (UserMappingArray) ElementType() reflect.Type

func (UserMappingArray) ToOutput

func (UserMappingArray) ToUserMappingArrayOutput

func (i UserMappingArray) ToUserMappingArrayOutput() UserMappingArrayOutput

func (UserMappingArray) ToUserMappingArrayOutputWithContext

func (i UserMappingArray) ToUserMappingArrayOutputWithContext(ctx context.Context) UserMappingArrayOutput

type UserMappingArrayInput

type UserMappingArrayInput interface {
	pulumi.Input

	ToUserMappingArrayOutput() UserMappingArrayOutput
	ToUserMappingArrayOutputWithContext(context.Context) UserMappingArrayOutput
}

UserMappingArrayInput is an input type that accepts UserMappingArray and UserMappingArrayOutput values. You can construct a concrete instance of `UserMappingArrayInput` via:

UserMappingArray{ UserMappingArgs{...} }

type UserMappingArrayOutput

type UserMappingArrayOutput struct{ *pulumi.OutputState }

func (UserMappingArrayOutput) ElementType

func (UserMappingArrayOutput) ElementType() reflect.Type

func (UserMappingArrayOutput) Index

func (UserMappingArrayOutput) ToOutput

func (UserMappingArrayOutput) ToUserMappingArrayOutput

func (o UserMappingArrayOutput) ToUserMappingArrayOutput() UserMappingArrayOutput

func (UserMappingArrayOutput) ToUserMappingArrayOutputWithContext

func (o UserMappingArrayOutput) ToUserMappingArrayOutputWithContext(ctx context.Context) UserMappingArrayOutput

type UserMappingInput

type UserMappingInput interface {
	pulumi.Input

	ToUserMappingOutput() UserMappingOutput
	ToUserMappingOutputWithContext(context.Context) UserMappingOutput
}

UserMappingInput is an input type that accepts UserMappingArgs and UserMappingOutput values. You can construct a concrete instance of `UserMappingInput` via:

UserMappingArgs{...}

type UserMappingOutput

type UserMappingOutput struct{ *pulumi.OutputState }

Describes a mapping from an AWS IAM user to a Kubernetes user and groups.

func (UserMappingOutput) ElementType

func (UserMappingOutput) ElementType() reflect.Type

func (UserMappingOutput) Groups

A list of groups within Kubernetes to which the user is mapped to.

func (UserMappingOutput) ToOutput

func (UserMappingOutput) ToUserMappingOutput

func (o UserMappingOutput) ToUserMappingOutput() UserMappingOutput

func (UserMappingOutput) ToUserMappingOutputWithContext

func (o UserMappingOutput) ToUserMappingOutputWithContext(ctx context.Context) UserMappingOutput

func (UserMappingOutput) UserArn

The ARN of the IAM user to add.

func (UserMappingOutput) Username

func (o UserMappingOutput) Username() pulumi.StringOutput

The user name within Kubernetes to map to the IAM user. By default, the user name is the ARN of the IAM user.

type VpcCni

type VpcCni struct {
	pulumi.CustomResourceState
}

VpcCni manages the configuration of the Amazon VPC CNI plugin for Kubernetes by applying its YAML chart.

func GetVpcCni

func GetVpcCni(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *VpcCniState, opts ...pulumi.ResourceOption) (*VpcCni, error)

GetVpcCni gets an existing VpcCni resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewVpcCni

func NewVpcCni(ctx *pulumi.Context,
	name string, args *VpcCniArgs, opts ...pulumi.ResourceOption) (*VpcCni, error)

NewVpcCni registers a new resource with the given unique name, arguments, and options.

func (*VpcCni) ElementType

func (*VpcCni) ElementType() reflect.Type

func (*VpcCni) ToOutput

func (i *VpcCni) ToOutput(ctx context.Context) pulumix.Output[*VpcCni]

func (*VpcCni) ToVpcCniOutput

func (i *VpcCni) ToVpcCniOutput() VpcCniOutput

func (*VpcCni) ToVpcCniOutputWithContext

func (i *VpcCni) ToVpcCniOutputWithContext(ctx context.Context) VpcCniOutput

type VpcCniArgs

type VpcCniArgs struct {
	// Specifies whether ipamd should configure rp filter for primary interface. Default is `false`.
	CniConfigureRpfilter pulumi.BoolPtrInput
	// Specifies that your pods may use subnets and security groups that are independent of your worker node's VPC configuration. By default, pods share the same subnet and security groups as the worker node's primary interface. Setting this variable to true causes ipamd to use the security groups and VPC subnet in a worker node's ENIConfig for elastic network interface allocation. You must create an ENIConfig custom resource for each subnet that your pods will reside in, and then annotate or label each worker node to use a specific ENIConfig (multiple worker nodes can be annotated or labelled with the same ENIConfig). Worker nodes can only be annotated with a single ENIConfig at a time, and the subnet in the ENIConfig must belong to the same Availability Zone that the worker node resides in. For more information, see CNI Custom Networking in the Amazon EKS User Guide. Default is `false`
	CniCustomNetworkCfg pulumi.BoolPtrInput
	// Specifies whether an external NAT gateway should be used to provide SNAT of secondary ENI IP addresses. If set to true, the SNAT iptables rule and off-VPC IP rule are not applied, and these rules are removed if they have already been applied. Disable SNAT if you need to allow inbound communication to your pods from external VPNs, direct connections, and external VPCs, and your pods do not need to access the Internet directly via an Internet Gateway. However, your nodes must be running in a private subnet and connected to the internet through an AWS NAT Gateway or another external NAT device. Default is `false`
	CniExternalSnat pulumi.BoolPtrInput
	// Specifies that your pods may use subnets and security groups (within the same VPC as your control plane resources) that are independent of your cluster's `resourcesVpcConfig`.
	//
	// Defaults to false.
	CustomNetworkConfig pulumi.BoolPtrInput
	// Allows the kubelet's liveness and readiness probes to connect via TCP when pod ENI is enabled. This will slightly increase local TCP connection latency.
	DisableTcpEarlyDemux pulumi.BoolPtrInput
	// VPC CNI can operate in either IPv4 or IPv6 mode. Setting ENABLE_IPv6 to true. will configure it in IPv6 mode. IPv6 is only supported in Prefix Delegation mode, so ENABLE_PREFIX_DELEGATION needs to set to true if VPC CNI is configured to operate in IPv6 mode. Prefix delegation is only supported on nitro instances.
	EnableIpv6 pulumi.BoolPtrInput
	// Specifies whether to allow IPAMD to add the `vpc.amazonaws.com/has-trunk-attached` label to the node if the instance has capacity to attach an additional ENI. Default is `false`. If using liveness and readiness probes, you will also need to disable TCP early demux.
	EnablePodEni pulumi.BoolPtrInput
	// IPAMD will start allocating (/28) prefixes to the ENIs with ENABLE_PREFIX_DELEGATION set to true.
	EnablePrefixDelegation pulumi.BoolPtrInput
	// Specifies the ENI_CONFIG_LABEL_DEF environment variable value for worker nodes. This is used to tell Kubernetes to automatically apply the ENIConfig for each Availability Zone
	// Ref: https://docs.aws.amazon.com/eks/latest/userguide/cni-custom-network.html (step 5(c))
	//
	// Defaults to the official AWS CNI image in ECR.
	EniConfigLabelDef pulumi.StringPtrInput
	// Used to configure the MTU size for attached ENIs. The valid range is from 576 to 9001.
	//
	// Defaults to 9001.
	EniMtu pulumi.IntPtrInput
	// Specifies whether an external NAT gateway should be used to provide SNAT of secondary ENI IP addresses. If set to true, the SNAT iptables rule and off-VPC IP rule are not applied, and these rules are removed if they have already been applied.
	//
	// Defaults to false.
	ExternalSnat pulumi.BoolPtrInput
	// Specifies the container image to use in the AWS CNI cluster DaemonSet.
	//
	// Defaults to the official AWS CNI image in ECR.
	Image pulumi.StringPtrInput
	// Specifies the init container image to use in the AWS CNI cluster DaemonSet.
	//
	// Defaults to the official AWS CNI init container image in ECR.
	InitImage pulumi.StringPtrInput
	// The kubeconfig to use when setting the VPC CNI options.
	Kubeconfig pulumi.Input
	// Specifies the file path used for logs.
	//
	// Defaults to "stdout" to emit Pod logs for `kubectl logs`.
	LogFile pulumi.StringPtrInput
	// Specifies the log level used for logs.
	//
	// Defaults to "DEBUG"
	// Valid values: "DEBUG", "INFO", "WARN", "ERROR", or "FATAL".
	LogLevel pulumi.StringPtrInput
	// Specifies whether NodePort services are enabled on a worker node's primary network interface. This requires additional iptables rules and that the kernel's reverse path filter on the primary interface is set to loose.
	//
	// Defaults to true.
	NodePortSupport pulumi.BoolPtrInput
	// Pass privilege to containers securityContext. This is required when SELinux is enabled. This value will not be passed to the CNI config by default
	SecurityContextPrivileged pulumi.BoolPtrInput
	// Specifies the veth prefix used to generate the host-side veth device name for the CNI.
	//
	// The prefix can be at most 4 characters long.
	//
	// Defaults to "eni".
	VethPrefix pulumi.StringPtrInput
	// Specifies the number of free elastic network interfaces (and all of their available IP addresses) that the ipamD daemon should attempt to keep available for pod assignment on the node.
	//
	// Defaults to 1.
	WarmEniTarget pulumi.IntPtrInput
	// Specifies the number of free IP addresses that the ipamD daemon should attempt to keep available for pod assignment on the node.
	WarmIpTarget pulumi.IntPtrInput
	// WARM_PREFIX_TARGET will allocate one full (/28) prefix even if a single IP  is consumed with the existing prefix. Ref: https://github.com/aws/amazon-vpc-cni-k8s/blob/master/docs/prefix-and-ip-target.md
	WarmPrefixTarget pulumi.IntPtrInput
}

The set of arguments for constructing a VpcCni resource.

func (VpcCniArgs) ElementType

func (VpcCniArgs) ElementType() reflect.Type

type VpcCniArray

type VpcCniArray []VpcCniInput

func (VpcCniArray) ElementType

func (VpcCniArray) ElementType() reflect.Type

func (VpcCniArray) ToOutput

func (i VpcCniArray) ToOutput(ctx context.Context) pulumix.Output[[]*VpcCni]

func (VpcCniArray) ToVpcCniArrayOutput

func (i VpcCniArray) ToVpcCniArrayOutput() VpcCniArrayOutput

func (VpcCniArray) ToVpcCniArrayOutputWithContext

func (i VpcCniArray) ToVpcCniArrayOutputWithContext(ctx context.Context) VpcCniArrayOutput

type VpcCniArrayInput

type VpcCniArrayInput interface {
	pulumi.Input

	ToVpcCniArrayOutput() VpcCniArrayOutput
	ToVpcCniArrayOutputWithContext(context.Context) VpcCniArrayOutput
}

VpcCniArrayInput is an input type that accepts VpcCniArray and VpcCniArrayOutput values. You can construct a concrete instance of `VpcCniArrayInput` via:

VpcCniArray{ VpcCniArgs{...} }

type VpcCniArrayOutput

type VpcCniArrayOutput struct{ *pulumi.OutputState }

func (VpcCniArrayOutput) ElementType

func (VpcCniArrayOutput) ElementType() reflect.Type

func (VpcCniArrayOutput) Index

func (VpcCniArrayOutput) ToOutput

func (o VpcCniArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]*VpcCni]

func (VpcCniArrayOutput) ToVpcCniArrayOutput

func (o VpcCniArrayOutput) ToVpcCniArrayOutput() VpcCniArrayOutput

func (VpcCniArrayOutput) ToVpcCniArrayOutputWithContext

func (o VpcCniArrayOutput) ToVpcCniArrayOutputWithContext(ctx context.Context) VpcCniArrayOutput

type VpcCniInput

type VpcCniInput interface {
	pulumi.Input

	ToVpcCniOutput() VpcCniOutput
	ToVpcCniOutputWithContext(ctx context.Context) VpcCniOutput
}

type VpcCniMap

type VpcCniMap map[string]VpcCniInput

func (VpcCniMap) ElementType

func (VpcCniMap) ElementType() reflect.Type

func (VpcCniMap) ToOutput

func (i VpcCniMap) ToOutput(ctx context.Context) pulumix.Output[map[string]*VpcCni]

func (VpcCniMap) ToVpcCniMapOutput

func (i VpcCniMap) ToVpcCniMapOutput() VpcCniMapOutput

func (VpcCniMap) ToVpcCniMapOutputWithContext

func (i VpcCniMap) ToVpcCniMapOutputWithContext(ctx context.Context) VpcCniMapOutput

type VpcCniMapInput

type VpcCniMapInput interface {
	pulumi.Input

	ToVpcCniMapOutput() VpcCniMapOutput
	ToVpcCniMapOutputWithContext(context.Context) VpcCniMapOutput
}

VpcCniMapInput is an input type that accepts VpcCniMap and VpcCniMapOutput values. You can construct a concrete instance of `VpcCniMapInput` via:

VpcCniMap{ "key": VpcCniArgs{...} }

type VpcCniMapOutput

type VpcCniMapOutput struct{ *pulumi.OutputState }

func (VpcCniMapOutput) ElementType

func (VpcCniMapOutput) ElementType() reflect.Type

func (VpcCniMapOutput) MapIndex

func (VpcCniMapOutput) ToOutput

func (o VpcCniMapOutput) ToOutput(ctx context.Context) pulumix.Output[map[string]*VpcCni]

func (VpcCniMapOutput) ToVpcCniMapOutput

func (o VpcCniMapOutput) ToVpcCniMapOutput() VpcCniMapOutput

func (VpcCniMapOutput) ToVpcCniMapOutputWithContext

func (o VpcCniMapOutput) ToVpcCniMapOutputWithContext(ctx context.Context) VpcCniMapOutput

type VpcCniOptions

type VpcCniOptions struct {
	// Specifies whether ipamd should configure rp filter for primary interface. Default is `false`.
	CniConfigureRpfilter *bool `pulumi:"cniConfigureRpfilter"`
	// Specifies that your pods may use subnets and security groups that are independent of your worker node's VPC configuration. By default, pods share the same subnet and security groups as the worker node's primary interface. Setting this variable to true causes ipamd to use the security groups and VPC subnet in a worker node's ENIConfig for elastic network interface allocation. You must create an ENIConfig custom resource for each subnet that your pods will reside in, and then annotate or label each worker node to use a specific ENIConfig (multiple worker nodes can be annotated or labelled with the same ENIConfig). Worker nodes can only be annotated with a single ENIConfig at a time, and the subnet in the ENIConfig must belong to the same Availability Zone that the worker node resides in. For more information, see CNI Custom Networking in the Amazon EKS User Guide. Default is `false`
	CniCustomNetworkCfg *bool `pulumi:"cniCustomNetworkCfg"`
	// Specifies whether an external NAT gateway should be used to provide SNAT of secondary ENI IP addresses. If set to true, the SNAT iptables rule and off-VPC IP rule are not applied, and these rules are removed if they have already been applied. Disable SNAT if you need to allow inbound communication to your pods from external VPNs, direct connections, and external VPCs, and your pods do not need to access the Internet directly via an Internet Gateway. However, your nodes must be running in a private subnet and connected to the internet through an AWS NAT Gateway or another external NAT device. Default is `false`
	CniExternalSnat *bool `pulumi:"cniExternalSnat"`
	// Specifies that your pods may use subnets and security groups (within the same VPC as your control plane resources) that are independent of your cluster's `resourcesVpcConfig`.
	//
	// Defaults to false.
	CustomNetworkConfig *bool `pulumi:"customNetworkConfig"`
	// Allows the kubelet's liveness and readiness probes to connect via TCP when pod ENI is enabled. This will slightly increase local TCP connection latency.
	DisableTcpEarlyDemux *bool `pulumi:"disableTcpEarlyDemux"`
	// VPC CNI can operate in either IPv4 or IPv6 mode. Setting ENABLE_IPv6 to true. will configure it in IPv6 mode. IPv6 is only supported in Prefix Delegation mode, so ENABLE_PREFIX_DELEGATION needs to set to true if VPC CNI is configured to operate in IPv6 mode. Prefix delegation is only supported on nitro instances.
	EnableIpv6 *bool `pulumi:"enableIpv6"`
	// Specifies whether to allow IPAMD to add the `vpc.amazonaws.com/has-trunk-attached` label to the node if the instance has capacity to attach an additional ENI. Default is `false`. If using liveness and readiness probes, you will also need to disable TCP early demux.
	EnablePodEni *bool `pulumi:"enablePodEni"`
	// IPAMD will start allocating (/28) prefixes to the ENIs with ENABLE_PREFIX_DELEGATION set to true.
	EnablePrefixDelegation *bool `pulumi:"enablePrefixDelegation"`
	// Specifies the ENI_CONFIG_LABEL_DEF environment variable value for worker nodes. This is used to tell Kubernetes to automatically apply the ENIConfig for each Availability Zone
	// Ref: https://docs.aws.amazon.com/eks/latest/userguide/cni-custom-network.html (step 5(c))
	//
	// Defaults to the official AWS CNI image in ECR.
	EniConfigLabelDef *string `pulumi:"eniConfigLabelDef"`
	// Used to configure the MTU size for attached ENIs. The valid range is from 576 to 9001.
	//
	// Defaults to 9001.
	EniMtu *int `pulumi:"eniMtu"`
	// Specifies whether an external NAT gateway should be used to provide SNAT of secondary ENI IP addresses. If set to true, the SNAT iptables rule and off-VPC IP rule are not applied, and these rules are removed if they have already been applied.
	//
	// Defaults to false.
	ExternalSnat *bool `pulumi:"externalSnat"`
	// Specifies the container image to use in the AWS CNI cluster DaemonSet.
	//
	// Defaults to the official AWS CNI image in ECR.
	Image *string `pulumi:"image"`
	// Specifies the init container image to use in the AWS CNI cluster DaemonSet.
	//
	// Defaults to the official AWS CNI init container image in ECR.
	InitImage *string `pulumi:"initImage"`
	// Specifies the file path used for logs.
	//
	// Defaults to "stdout" to emit Pod logs for `kubectl logs`.
	LogFile *string `pulumi:"logFile"`
	// Specifies the log level used for logs.
	//
	// Defaults to "DEBUG"
	// Valid values: "DEBUG", "INFO", "WARN", "ERROR", or "FATAL".
	LogLevel *string `pulumi:"logLevel"`
	// Specifies whether NodePort services are enabled on a worker node's primary network interface. This requires additional iptables rules and that the kernel's reverse path filter on the primary interface is set to loose.
	//
	// Defaults to true.
	NodePortSupport *bool `pulumi:"nodePortSupport"`
	// Pass privilege to containers securityContext. This is required when SELinux is enabled. This value will not be passed to the CNI config by default
	SecurityContextPrivileged *bool `pulumi:"securityContextPrivileged"`
	// Specifies the veth prefix used to generate the host-side veth device name for the CNI.
	//
	// The prefix can be at most 4 characters long.
	//
	// Defaults to "eni".
	VethPrefix *string `pulumi:"vethPrefix"`
	// Specifies the number of free elastic network interfaces (and all of their available IP addresses) that the ipamD daemon should attempt to keep available for pod assignment on the node.
	//
	// Defaults to 1.
	WarmEniTarget *int `pulumi:"warmEniTarget"`
	// Specifies the number of free IP addresses that the ipamD daemon should attempt to keep available for pod assignment on the node.
	WarmIpTarget *int `pulumi:"warmIpTarget"`
	// WARM_PREFIX_TARGET will allocate one full (/28) prefix even if a single IP  is consumed with the existing prefix. Ref: https://github.com/aws/amazon-vpc-cni-k8s/blob/master/docs/prefix-and-ip-target.md
	WarmPrefixTarget *int `pulumi:"warmPrefixTarget"`
}

Describes the configuration options available for the Amazon VPC CNI plugin for Kubernetes.

type VpcCniOptionsArgs

type VpcCniOptionsArgs struct {
	// Specifies whether ipamd should configure rp filter for primary interface. Default is `false`.
	CniConfigureRpfilter pulumi.BoolPtrInput `pulumi:"cniConfigureRpfilter"`
	// Specifies that your pods may use subnets and security groups that are independent of your worker node's VPC configuration. By default, pods share the same subnet and security groups as the worker node's primary interface. Setting this variable to true causes ipamd to use the security groups and VPC subnet in a worker node's ENIConfig for elastic network interface allocation. You must create an ENIConfig custom resource for each subnet that your pods will reside in, and then annotate or label each worker node to use a specific ENIConfig (multiple worker nodes can be annotated or labelled with the same ENIConfig). Worker nodes can only be annotated with a single ENIConfig at a time, and the subnet in the ENIConfig must belong to the same Availability Zone that the worker node resides in. For more information, see CNI Custom Networking in the Amazon EKS User Guide. Default is `false`
	CniCustomNetworkCfg pulumi.BoolPtrInput `pulumi:"cniCustomNetworkCfg"`
	// Specifies whether an external NAT gateway should be used to provide SNAT of secondary ENI IP addresses. If set to true, the SNAT iptables rule and off-VPC IP rule are not applied, and these rules are removed if they have already been applied. Disable SNAT if you need to allow inbound communication to your pods from external VPNs, direct connections, and external VPCs, and your pods do not need to access the Internet directly via an Internet Gateway. However, your nodes must be running in a private subnet and connected to the internet through an AWS NAT Gateway or another external NAT device. Default is `false`
	CniExternalSnat pulumi.BoolPtrInput `pulumi:"cniExternalSnat"`
	// Specifies that your pods may use subnets and security groups (within the same VPC as your control plane resources) that are independent of your cluster's `resourcesVpcConfig`.
	//
	// Defaults to false.
	CustomNetworkConfig pulumi.BoolPtrInput `pulumi:"customNetworkConfig"`
	// Allows the kubelet's liveness and readiness probes to connect via TCP when pod ENI is enabled. This will slightly increase local TCP connection latency.
	DisableTcpEarlyDemux pulumi.BoolPtrInput `pulumi:"disableTcpEarlyDemux"`
	// VPC CNI can operate in either IPv4 or IPv6 mode. Setting ENABLE_IPv6 to true. will configure it in IPv6 mode. IPv6 is only supported in Prefix Delegation mode, so ENABLE_PREFIX_DELEGATION needs to set to true if VPC CNI is configured to operate in IPv6 mode. Prefix delegation is only supported on nitro instances.
	EnableIpv6 pulumi.BoolPtrInput `pulumi:"enableIpv6"`
	// Specifies whether to allow IPAMD to add the `vpc.amazonaws.com/has-trunk-attached` label to the node if the instance has capacity to attach an additional ENI. Default is `false`. If using liveness and readiness probes, you will also need to disable TCP early demux.
	EnablePodEni pulumi.BoolPtrInput `pulumi:"enablePodEni"`
	// IPAMD will start allocating (/28) prefixes to the ENIs with ENABLE_PREFIX_DELEGATION set to true.
	EnablePrefixDelegation pulumi.BoolPtrInput `pulumi:"enablePrefixDelegation"`
	// Specifies the ENI_CONFIG_LABEL_DEF environment variable value for worker nodes. This is used to tell Kubernetes to automatically apply the ENIConfig for each Availability Zone
	// Ref: https://docs.aws.amazon.com/eks/latest/userguide/cni-custom-network.html (step 5(c))
	//
	// Defaults to the official AWS CNI image in ECR.
	EniConfigLabelDef pulumi.StringPtrInput `pulumi:"eniConfigLabelDef"`
	// Used to configure the MTU size for attached ENIs. The valid range is from 576 to 9001.
	//
	// Defaults to 9001.
	EniMtu pulumi.IntPtrInput `pulumi:"eniMtu"`
	// Specifies whether an external NAT gateway should be used to provide SNAT of secondary ENI IP addresses. If set to true, the SNAT iptables rule and off-VPC IP rule are not applied, and these rules are removed if they have already been applied.
	//
	// Defaults to false.
	ExternalSnat pulumi.BoolPtrInput `pulumi:"externalSnat"`
	// Specifies the container image to use in the AWS CNI cluster DaemonSet.
	//
	// Defaults to the official AWS CNI image in ECR.
	Image pulumi.StringPtrInput `pulumi:"image"`
	// Specifies the init container image to use in the AWS CNI cluster DaemonSet.
	//
	// Defaults to the official AWS CNI init container image in ECR.
	InitImage pulumi.StringPtrInput `pulumi:"initImage"`
	// Specifies the file path used for logs.
	//
	// Defaults to "stdout" to emit Pod logs for `kubectl logs`.
	LogFile pulumi.StringPtrInput `pulumi:"logFile"`
	// Specifies the log level used for logs.
	//
	// Defaults to "DEBUG"
	// Valid values: "DEBUG", "INFO", "WARN", "ERROR", or "FATAL".
	LogLevel pulumi.StringPtrInput `pulumi:"logLevel"`
	// Specifies whether NodePort services are enabled on a worker node's primary network interface. This requires additional iptables rules and that the kernel's reverse path filter on the primary interface is set to loose.
	//
	// Defaults to true.
	NodePortSupport pulumi.BoolPtrInput `pulumi:"nodePortSupport"`
	// Pass privilege to containers securityContext. This is required when SELinux is enabled. This value will not be passed to the CNI config by default
	SecurityContextPrivileged pulumi.BoolPtrInput `pulumi:"securityContextPrivileged"`
	// Specifies the veth prefix used to generate the host-side veth device name for the CNI.
	//
	// The prefix can be at most 4 characters long.
	//
	// Defaults to "eni".
	VethPrefix pulumi.StringPtrInput `pulumi:"vethPrefix"`
	// Specifies the number of free elastic network interfaces (and all of their available IP addresses) that the ipamD daemon should attempt to keep available for pod assignment on the node.
	//
	// Defaults to 1.
	WarmEniTarget pulumi.IntPtrInput `pulumi:"warmEniTarget"`
	// Specifies the number of free IP addresses that the ipamD daemon should attempt to keep available for pod assignment on the node.
	WarmIpTarget pulumi.IntPtrInput `pulumi:"warmIpTarget"`
	// WARM_PREFIX_TARGET will allocate one full (/28) prefix even if a single IP  is consumed with the existing prefix. Ref: https://github.com/aws/amazon-vpc-cni-k8s/blob/master/docs/prefix-and-ip-target.md
	WarmPrefixTarget pulumi.IntPtrInput `pulumi:"warmPrefixTarget"`
}

Describes the configuration options available for the Amazon VPC CNI plugin for Kubernetes.

func (VpcCniOptionsArgs) ElementType

func (VpcCniOptionsArgs) ElementType() reflect.Type

func (VpcCniOptionsArgs) ToOutput

func (VpcCniOptionsArgs) ToVpcCniOptionsOutput

func (i VpcCniOptionsArgs) ToVpcCniOptionsOutput() VpcCniOptionsOutput

func (VpcCniOptionsArgs) ToVpcCniOptionsOutputWithContext

func (i VpcCniOptionsArgs) ToVpcCniOptionsOutputWithContext(ctx context.Context) VpcCniOptionsOutput

func (VpcCniOptionsArgs) ToVpcCniOptionsPtrOutput

func (i VpcCniOptionsArgs) ToVpcCniOptionsPtrOutput() VpcCniOptionsPtrOutput

func (VpcCniOptionsArgs) ToVpcCniOptionsPtrOutputWithContext

func (i VpcCniOptionsArgs) ToVpcCniOptionsPtrOutputWithContext(ctx context.Context) VpcCniOptionsPtrOutput

type VpcCniOptionsInput

type VpcCniOptionsInput interface {
	pulumi.Input

	ToVpcCniOptionsOutput() VpcCniOptionsOutput
	ToVpcCniOptionsOutputWithContext(context.Context) VpcCniOptionsOutput
}

VpcCniOptionsInput is an input type that accepts VpcCniOptionsArgs and VpcCniOptionsOutput values. You can construct a concrete instance of `VpcCniOptionsInput` via:

VpcCniOptionsArgs{...}

type VpcCniOptionsOutput

type VpcCniOptionsOutput struct{ *pulumi.OutputState }

Describes the configuration options available for the Amazon VPC CNI plugin for Kubernetes.

func (VpcCniOptionsOutput) CniConfigureRpfilter

func (o VpcCniOptionsOutput) CniConfigureRpfilter() pulumi.BoolPtrOutput

Specifies whether ipamd should configure rp filter for primary interface. Default is `false`.

func (VpcCniOptionsOutput) CniCustomNetworkCfg

func (o VpcCniOptionsOutput) CniCustomNetworkCfg() pulumi.BoolPtrOutput

Specifies that your pods may use subnets and security groups that are independent of your worker node's VPC configuration. By default, pods share the same subnet and security groups as the worker node's primary interface. Setting this variable to true causes ipamd to use the security groups and VPC subnet in a worker node's ENIConfig for elastic network interface allocation. You must create an ENIConfig custom resource for each subnet that your pods will reside in, and then annotate or label each worker node to use a specific ENIConfig (multiple worker nodes can be annotated or labelled with the same ENIConfig). Worker nodes can only be annotated with a single ENIConfig at a time, and the subnet in the ENIConfig must belong to the same Availability Zone that the worker node resides in. For more information, see CNI Custom Networking in the Amazon EKS User Guide. Default is `false`

func (VpcCniOptionsOutput) CniExternalSnat

func (o VpcCniOptionsOutput) CniExternalSnat() pulumi.BoolPtrOutput

Specifies whether an external NAT gateway should be used to provide SNAT of secondary ENI IP addresses. If set to true, the SNAT iptables rule and off-VPC IP rule are not applied, and these rules are removed if they have already been applied. Disable SNAT if you need to allow inbound communication to your pods from external VPNs, direct connections, and external VPCs, and your pods do not need to access the Internet directly via an Internet Gateway. However, your nodes must be running in a private subnet and connected to the internet through an AWS NAT Gateway or another external NAT device. Default is `false`

func (VpcCniOptionsOutput) CustomNetworkConfig

func (o VpcCniOptionsOutput) CustomNetworkConfig() pulumi.BoolPtrOutput

Specifies that your pods may use subnets and security groups (within the same VPC as your control plane resources) that are independent of your cluster's `resourcesVpcConfig`.

Defaults to false.

func (VpcCniOptionsOutput) DisableTcpEarlyDemux

func (o VpcCniOptionsOutput) DisableTcpEarlyDemux() pulumi.BoolPtrOutput

Allows the kubelet's liveness and readiness probes to connect via TCP when pod ENI is enabled. This will slightly increase local TCP connection latency.

func (VpcCniOptionsOutput) ElementType

func (VpcCniOptionsOutput) ElementType() reflect.Type

func (VpcCniOptionsOutput) EnableIpv6

func (o VpcCniOptionsOutput) EnableIpv6() pulumi.BoolPtrOutput

VPC CNI can operate in either IPv4 or IPv6 mode. Setting ENABLE_IPv6 to true. will configure it in IPv6 mode. IPv6 is only supported in Prefix Delegation mode, so ENABLE_PREFIX_DELEGATION needs to set to true if VPC CNI is configured to operate in IPv6 mode. Prefix delegation is only supported on nitro instances.

func (VpcCniOptionsOutput) EnablePodEni

func (o VpcCniOptionsOutput) EnablePodEni() pulumi.BoolPtrOutput

Specifies whether to allow IPAMD to add the `vpc.amazonaws.com/has-trunk-attached` label to the node if the instance has capacity to attach an additional ENI. Default is `false`. If using liveness and readiness probes, you will also need to disable TCP early demux.

func (VpcCniOptionsOutput) EnablePrefixDelegation

func (o VpcCniOptionsOutput) EnablePrefixDelegation() pulumi.BoolPtrOutput

IPAMD will start allocating (/28) prefixes to the ENIs with ENABLE_PREFIX_DELEGATION set to true.

func (VpcCniOptionsOutput) EniConfigLabelDef

func (o VpcCniOptionsOutput) EniConfigLabelDef() pulumi.StringPtrOutput

Specifies the ENI_CONFIG_LABEL_DEF environment variable value for worker nodes. This is used to tell Kubernetes to automatically apply the ENIConfig for each Availability Zone Ref: https://docs.aws.amazon.com/eks/latest/userguide/cni-custom-network.html (step 5(c))

Defaults to the official AWS CNI image in ECR.

func (VpcCniOptionsOutput) EniMtu

Used to configure the MTU size for attached ENIs. The valid range is from 576 to 9001.

Defaults to 9001.

func (VpcCniOptionsOutput) ExternalSnat

func (o VpcCniOptionsOutput) ExternalSnat() pulumi.BoolPtrOutput

Specifies whether an external NAT gateway should be used to provide SNAT of secondary ENI IP addresses. If set to true, the SNAT iptables rule and off-VPC IP rule are not applied, and these rules are removed if they have already been applied.

Defaults to false.

func (VpcCniOptionsOutput) Image

Specifies the container image to use in the AWS CNI cluster DaemonSet.

Defaults to the official AWS CNI image in ECR.

func (VpcCniOptionsOutput) InitImage

Specifies the init container image to use in the AWS CNI cluster DaemonSet.

Defaults to the official AWS CNI init container image in ECR.

func (VpcCniOptionsOutput) LogFile

Specifies the file path used for logs.

Defaults to "stdout" to emit Pod logs for `kubectl logs`.

func (VpcCniOptionsOutput) LogLevel

Specifies the log level used for logs.

Defaults to "DEBUG" Valid values: "DEBUG", "INFO", "WARN", "ERROR", or "FATAL".

func (VpcCniOptionsOutput) NodePortSupport

func (o VpcCniOptionsOutput) NodePortSupport() pulumi.BoolPtrOutput

Specifies whether NodePort services are enabled on a worker node's primary network interface. This requires additional iptables rules and that the kernel's reverse path filter on the primary interface is set to loose.

Defaults to true.

func (VpcCniOptionsOutput) SecurityContextPrivileged

func (o VpcCniOptionsOutput) SecurityContextPrivileged() pulumi.BoolPtrOutput

Pass privilege to containers securityContext. This is required when SELinux is enabled. This value will not be passed to the CNI config by default

func (VpcCniOptionsOutput) ToOutput

func (VpcCniOptionsOutput) ToVpcCniOptionsOutput

func (o VpcCniOptionsOutput) ToVpcCniOptionsOutput() VpcCniOptionsOutput

func (VpcCniOptionsOutput) ToVpcCniOptionsOutputWithContext

func (o VpcCniOptionsOutput) ToVpcCniOptionsOutputWithContext(ctx context.Context) VpcCniOptionsOutput

func (VpcCniOptionsOutput) ToVpcCniOptionsPtrOutput

func (o VpcCniOptionsOutput) ToVpcCniOptionsPtrOutput() VpcCniOptionsPtrOutput

func (VpcCniOptionsOutput) ToVpcCniOptionsPtrOutputWithContext

func (o VpcCniOptionsOutput) ToVpcCniOptionsPtrOutputWithContext(ctx context.Context) VpcCniOptionsPtrOutput