Module types 

Data structures used by operation inputs/outputs.

Modules

builders

Builders

error

Error types that Amazon Elastic Kubernetes Service can respond with.

Structs

AccessConfigResponse

The access configuration for the cluster.

AccessEntry

An access entry allows an IAM principal (user or role) to access your cluster. Access entries can replace the need to maintain the aws-auth ConfigMap for authentication. For more information about access entries, see Access entries in the Amazon EKS User Guide.

AccessPolicy

An access policy includes permissions that allow Amazon EKS to authorize an IAM principal to work with Kubernetes objects on your cluster. The policies are managed by Amazon EKS, but they're not IAM policies. You can't view the permissions in the policies using the API. The permissions for many of the policies are similar to the Kubernetes cluster-admin, admin, edit, and view cluster roles. For more information about these cluster roles, see User-facing roles in the Kubernetes documentation. To view the contents of the policies, see Access policy permissions in the Amazon EKS User Guide.

AccessScope

The scope of an AccessPolicy that's associated to an AccessEntry.

Addon

An Amazon EKS add-on. For more information, see Amazon EKS add-ons in the Amazon EKS User Guide.

AddonCompatibilityDetail

The summary information about the Amazon EKS add-on compatibility for the next Kubernetes version for an insight check in the UPGRADE_READINESS category.

AddonHealth

The health of the add-on.

AddonInfo

Information about an add-on.

AddonIssue

An issue related to an add-on.

AddonNamespaceConfigRequest

The namespace configuration request object for specifying a custom namespace when creating an addon.

AddonNamespaceConfigResponse

The namespace configuration response object containing information about the namespace where an addon is installed.

AddonPodIdentityAssociations

A type of EKS Pod Identity association owned by an Amazon EKS add-on.

Each association maps a role to a service account in a namespace in the cluster.

For more information, see Attach an IAM Role to an Amazon EKS add-on using EKS Pod Identity in the Amazon EKS User Guide.

AddonPodIdentityConfiguration

Information about how to configure IAM for an add-on.

AddonVersionInfo

Information about an add-on version.

AssociatedAccessPolicy

An access policy association.

AutoScalingGroup

An Auto Scaling group that is associated with an Amazon EKS managed node group.

BlockStorage

Indicates the current configuration of the block storage capability on your EKS Auto Mode cluster. For example, if the capability is enabled or disabled. If the block storage capability is enabled, EKS Auto Mode will create and delete EBS volumes in your Amazon Web Services account. For more information, see EKS Auto Mode block storage capability in the Amazon EKS User Guide.

Certificate

An object representing the certificate-authority-data for your cluster.

ClientStat

Details about clients using the deprecated resources.

Cluster

An object representing an Amazon EKS cluster.

ClusterHealth

An object representing the health of your Amazon EKS cluster.

ClusterIssue

An issue with your Amazon EKS cluster.

ClusterVersionInformation

Contains details about a specific EKS cluster version.

Compatibility

Compatibility information.

ComputeConfigRequest

Request to update the configuration of the compute capability of your EKS Auto Mode cluster. For example, enable the capability. For more information, see EKS Auto Mode compute capability in the Amazon EKS User Guide.

ComputeConfigResponse

Indicates the status of the request to update the compute capability of your EKS Auto Mode cluster.

ConnectorConfigRequest

The configuration sent to a cluster for configuration.

ConnectorConfigResponse

The full description of your connected cluster.

ControlPlanePlacementRequest

The placement configuration for all the control plane instances of your local Amazon EKS cluster on an Amazon Web Services Outpost. For more information, see Capacity considerations in the Amazon EKS User Guide.

ControlPlanePlacementResponse

The placement configuration for all the control plane instances of your local Amazon EKS cluster on an Amazon Web Services Outpost. For more information, see Capacity considerations in the Amazon EKS User Guide.

CreateAccessConfigRequest

The access configuration information for the cluster.

DeprecationDetail

The summary information about deprecated resource usage for an insight check in the UPGRADE_READINESS category.

EksAnywhereSubscription

An EKS Anywhere subscription authorizing the customer to support for licensed clusters and access to EKS Anywhere Curated Packages.

EksAnywhereSubscriptionTerm

An object representing the term duration and term unit type of your subscription. This determines the term length of your subscription. Valid values are MONTHS for term unit and 12 or 36 for term duration, indicating a 12 month or 36 month subscription.

ElasticLoadBalancing

Indicates the current configuration of the load balancing capability on your EKS Auto Mode cluster. For example, if the capability is enabled or disabled. For more information, see EKS Auto Mode load balancing capability in the Amazon EKS User Guide.

EncryptionConfig

The encryption configuration for the cluster.

ErrorDetail

An object representing an error when an asynchronous operation fails.

FargateProfile

An object representing an Fargate profile.

FargateProfileHealth

The health status of the Fargate profile. If there are issues with your Fargate profile's health, they are listed here.

FargateProfileIssue

An issue that is associated with the Fargate profile.

FargateProfileSelector

An object representing an Fargate profile selector.

Identity

An object representing an identity provider.

IdentityProviderConfig

An object representing an identity provider configuration.

IdentityProviderConfigResponse

The full description of your identity configuration.

Insight

A check that provides recommendations to remedy potential upgrade-impacting issues.

InsightCategorySpecificSummary

Summary information that relates to the category of the insight. Currently only returned with certain insights having category UPGRADE_READINESS.

InsightResourceDetail

Returns information about the resource being evaluated.

InsightStatus

The status of the insight.

InsightSummary

The summarized description of the insight.

InsightsFilter

The criteria to use for the insights.

Issue

An object representing an issue with an Amazon EKS resource.

KubernetesNetworkConfigRequest

The Kubernetes network configuration for the cluster.

KubernetesNetworkConfigResponse

The Kubernetes network configuration for the cluster. The response contains a value for serviceIpv6Cidr or serviceIpv4Cidr, but not both.

LaunchTemplateSpecification

An object representing a node group launch template specification. The launch template can't include SubnetId , IamInstanceProfile , RequestSpotInstances , HibernationOptions , or TerminateInstances , or the node group deployment or update will fail. For more information about launch templates, see CreateLaunchTemplate in the Amazon EC2 API Reference. For more information about using launch templates with Amazon EKS, see Customizing managed nodes with launch templates in the Amazon EKS User Guide.

You must specify either the launch template ID or the launch template name in the request, but not both.

License

An EKS Anywhere license associated with a subscription.

LogSetup

An object representing the enabled or disabled Kubernetes control plane logs for your cluster.

Logging

An object representing the logging configuration for resources in your cluster.

MarketplaceInformation

Information about an Amazon EKS add-on from the Amazon Web Services Marketplace.

NodeRepairConfig

The node auto repair configuration for the node group.

Nodegroup

An object representing an Amazon EKS managed node group.

NodegroupHealth

An object representing the health status of the node group.

NodegroupResources

An object representing the resources associated with the node group, such as Auto Scaling groups and security groups for remote access.

NodegroupScalingConfig

An object representing the scaling configuration details for the Auto Scaling group that is associated with your node group. When creating a node group, you must specify all or none of the properties. When updating a node group, you can specify any or none of the properties.

NodegroupUpdateConfig

The node group update configuration. An Amazon EKS managed node group updates by replacing nodes with new nodes of newer AMI versions in parallel. You choose the maximum unavailable and the update strategy.

Oidc

An object representing the OpenID Connect (OIDC) identity provider information for the cluster.

OidcIdentityProviderConfig

An object representing the configuration for an OpenID Connect (OIDC) identity provider.

OidcIdentityProviderConfigRequest

An object representing an OpenID Connect (OIDC) configuration. Before associating an OIDC identity provider to your cluster, review the considerations in Authenticating users for your cluster from an OIDC identity provider in the Amazon EKS User Guide.

OutpostConfigRequest

The configuration of your local Amazon EKS cluster on an Amazon Web Services Outpost. Before creating a cluster on an Outpost, review Creating a local cluster on an Outpost in the Amazon EKS User Guide. This API isn't available for Amazon EKS clusters on the Amazon Web Services cloud.

OutpostConfigResponse

An object representing the configuration of your local Amazon EKS cluster on an Amazon Web Services Outpost. This API isn't available for Amazon EKS clusters on the Amazon Web Services cloud.

PodIdentityAssociation

Amazon EKS Pod Identity associations provide the ability to manage credentials for your applications, similar to the way that Amazon EC2 instance profiles provide credentials to Amazon EC2 instances.

PodIdentityAssociationSummary

The summarized description of the association.

Each summary is simplified by removing these fields compared to the full PodIdentityAssociation :

• The IAM role: roleArn

• The timestamp that the association was created at: createdAt

• The most recent timestamp that the association was modified at:. modifiedAt

• The tags on the association: tags

Provider

Identifies the Key Management Service (KMS) key used to encrypt the secrets.

RemoteAccessConfig

An object representing the remote access configuration for the managed node group.

RemoteNetworkConfigRequest

The configuration in the cluster for EKS Hybrid Nodes. You can add, change, or remove this configuration after the cluster is created.

RemoteNetworkConfigResponse

The configuration in the cluster for EKS Hybrid Nodes. You can add, change, or remove this configuration after the cluster is created.

RemoteNodeNetwork

A network CIDR that can contain hybrid nodes.

These CIDR blocks define the expected IP address range of the hybrid nodes that join the cluster. These blocks are typically determined by your network administrator.

Enter one or more IPv4 CIDR blocks in decimal dotted-quad notation (for example, 10.2.0.0/16).

It must satisfy the following requirements:

• Each block must be within an IPv4 RFC-1918 network range. Minimum allowed size is /32, maximum allowed size is /8. Publicly-routable addresses aren't supported.

• Each block cannot overlap with the range of the VPC CIDR blocks for your EKS resources, or the block of the Kubernetes service IP range.

• Each block must have a route to the VPC that uses the VPC CIDR blocks, not public IPs or Elastic IPs. There are many options including Transit Gateway, Site-to-Site VPN, or Direct Connect.

• Each host must allow outbound connection to the EKS cluster control plane on TCP ports 443 and 10250.

• Each host must allow inbound connection from the EKS cluster control plane on TCP port 10250 for logs, exec and port-forward operations.

• Each host must allow TCP and UDP network connectivity to and from other hosts that are running CoreDNS on UDP port 53 for service and pod DNS names.

RemotePodNetwork

A network CIDR that can contain pods that run Kubernetes webhooks on hybrid nodes.

These CIDR blocks are determined by configuring your Container Network Interface (CNI) plugin. We recommend the Calico CNI or Cilium CNI. Note that the Amazon VPC CNI plugin for Kubernetes isn't available for on-premises and edge locations.

Enter one or more IPv4 CIDR blocks in decimal dotted-quad notation (for example, 10.2.0.0/16).

It must satisfy the following requirements:

• Each block must be within an IPv4 RFC-1918 network range. Minimum allowed size is /32, maximum allowed size is /8. Publicly-routable addresses aren't supported.

• Each block cannot overlap with the range of the VPC CIDR blocks for your EKS resources, or the block of the Kubernetes service IP range.

StorageConfigRequest

Request to update the configuration of the storage capability of your EKS Auto Mode cluster. For example, enable the capability. For more information, see EKS Auto Mode block storage capability in the Amazon EKS User Guide.

StorageConfigResponse

Indicates the status of the request to update the block storage capability of your EKS Auto Mode cluster.

Taint

A property that allows a node to repel a Pod. For more information, see Node taints on managed node groups in the Amazon EKS User Guide.

Update

An object representing an asynchronous update.

UpdateAccessConfigRequest

The access configuration information for the cluster.

UpdateLabelsPayload

An object representing a Kubernetes label change for a managed node group.

UpdateParam

An object representing the details of an update request.

UpdateTaintsPayload

An object representing the details of an update to a taints payload. For more information, see Node taints on managed node groups in the Amazon EKS User Guide.

UpgradePolicyRequest

The support policy to use for the cluster. Extended support allows you to remain on specific Kubernetes versions for longer. Clusters in extended support have higher costs. The default value is EXTENDED. Use STANDARD to disable extended support.

Learn more about EKS Extended Support in the Amazon EKS User Guide.

UpgradePolicyResponse

This value indicates if extended support is enabled or disabled for the cluster.

Learn more about EKS Extended Support in the Amazon EKS User Guide.

VpcConfigRequest

An object representing the VPC configuration to use for an Amazon EKS cluster.

VpcConfigResponse

An object representing an Amazon EKS cluster VPC configuration response.

ZonalShiftConfigRequest

The configuration for zonal shift for the cluster.

ZonalShiftConfigResponse

The status of zonal shift configuration for the cluster

Enums

AccessScopeType

When writing a match expression against AccessScopeType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

AddonIssueCode

When writing a match expression against AddonIssueCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

AddonStatus

When writing a match expression against AddonStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

AmiTypes

When writing a match expression against AmiTypes, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

AuthenticationMode

When writing a match expression against AuthenticationMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

CapacityTypes

When writing a match expression against CapacityTypes, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Category

When writing a match expression against Category, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ClusterIssueCode

When writing a match expression against ClusterIssueCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ClusterStatus

When writing a match expression against ClusterStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ClusterVersionStatus

When writing a match expression against ClusterVersionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ConfigStatus

When writing a match expression against ConfigStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ConnectorConfigProvider

When writing a match expression against ConnectorConfigProvider, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

EksAnywhereSubscriptionLicenseType

When writing a match expression against EksAnywhereSubscriptionLicenseType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

EksAnywhereSubscriptionStatus

When writing a match expression against EksAnywhereSubscriptionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

EksAnywhereSubscriptionTermUnit

When writing a match expression against EksAnywhereSubscriptionTermUnit, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ErrorCode

When writing a match expression against ErrorCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

FargateProfileIssueCode

When writing a match expression against FargateProfileIssueCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

FargateProfileStatus

When writing a match expression against FargateProfileStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

InsightStatusValue

When writing a match expression against InsightStatusValue, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

InsightsRefreshStatus

When writing a match expression against InsightsRefreshStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

IpFamily

When writing a match expression against IpFamily, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

LogType

When writing a match expression against LogType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

NodegroupIssueCode

When writing a match expression against NodegroupIssueCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

NodegroupStatus

When writing a match expression against NodegroupStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

NodegroupUpdateStrategies

When writing a match expression against NodegroupUpdateStrategies, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

ResolveConflicts

When writing a match expression against ResolveConflicts, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

SupportType

When writing a match expression against SupportType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

TaintEffect

When writing a match expression against TaintEffect, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

UpdateParamType

When writing a match expression against UpdateParamType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

UpdateStatus

When writing a match expression against UpdateStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

UpdateType

When writing a match expression against UpdateType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

VersionStatus

When writing a match expression against VersionStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.