AWS Amazon Elastic Kubernetes Service
Browse all Amazonaws APIs61
AI ReadinessAI-Aware (B-)61/100
Agent-ready OpenAPI document · curated by JenticCloud InfrastructureContainer OrchestrationapiKey35 EndpointsREST
Know of an official OpenAPI document? Contribute it →
For Agents
Provision and manage Amazon EKS Kubernetes clusters, node groups, Fargate profiles, and add-ons across AWS regions through a single API.
Use for: I need to spin up a new EKS cluster in eu-west-1, Provision a managed node group with t3.medium instances, Set up a Fargate profile for the kube-system namespace, List all EKS clusters in this account
Not supported: Does not handle Kubernetes object operations, container image builds, or in-cluster RBAC policies - use for EKS control-plane and node-group management only.
Jentic publishes the only available OpenAPI specification for Amazon Elastic Kubernetes Service, keeping it validated and agent-ready. Amazon EKS is a managed Kubernetes service that runs upstream Kubernetes on AWS without requiring teams to operate the control plane themselves. The API covers cluster lifecycle management, managed node groups, Fargate profiles, EKS add-ons, and identity provider configuration. It is designed for platform teams that need to provision, scale, and upgrade Kubernetes clusters across multiple AWS regions while keeping pace with upstream Kubernetes releases.
Install Jentic One Beta
Connect the Amazon Elastic Kubernetes Service to your agent
Jentic One is a self-hosted execution layer for AI agents. It lets your agent call the Amazon Elastic Kubernetes Service, or any other public or private API you need. You set the rules, the agent never sees your credentials, and every call is logged.
Two steps, two machines. Install the instance in a safe environment, then register your agent from wherever it runs.
1
Step 1: Jentic One Host machine
# On the machine that will host your Jentic One instance:
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Famazonaws.com%2Famazon-eks" | sh2
Step 2: Agent machine
# On the machine where your agent runs (keep this separate from the instance):
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Famazonaws.com%2Famazon-eks" | sh
jentic register # connects your agent to your Jentic One instanceJentic One is in public beta. The setup above keeps your agent separate from the instance, which is what you want before using real credentials: an agent running as the same OS user as Jentic One can read its stored keys directly. Just evaluating? A single local install is fine to start. See the secure deployment guide for the tiers.
Capabilities
What an agent can do with Amazon Elastic Kubernetes Service API.
Create and delete EKS clusters with custom VPC, logging, and Kubernetes version configuration
Provision managed node groups with autoscaling settings, instance types, and AMI release versions
Attach Fargate profiles to run pods on serverless compute without managing EC2 nodes
Install, update, and remove EKS add-ons such as VPC CNI, CoreDNS, and kube-proxy
Associate OIDC identity provider configurations to authenticate Kubernetes users against external IdPs
Update cluster encryption configuration to enable envelope encryption of Kubernetes secrets
List and describe cluster, node group, and add-on update history for change auditing
Use Cases
Patterns agents use Amazon Elastic Kubernetes Service API for, with concrete tasks.
★ Multi-Region Kubernetes Platform Provisioning
Platform engineering teams use the Amazon EKS API to stand up production-grade Kubernetes clusters across multiple AWS regions with consistent network, logging, and encryption configuration. The API drives cluster creation, node group sizing, and Fargate profile attachment so teams can codify cluster topology in pipelines instead of clicking through the console. A typical regional rollout creates one cluster, two node groups, and three Fargate profiles in under thirty minutes when run as an automated workflow.
Create an EKS cluster named prod-eu in eu-west-1 with Kubernetes version 1.28, then attach a managed node group of three t3.large nodes.
Fargate Workload Onboarding
Teams migrating workloads to serverless containers use the EKS API to attach Fargate profiles that select pods by namespace and label. This removes the need to manage EC2 worker nodes for specific workloads while keeping the rest of the cluster on managed node groups. Fargate profile creation typically completes in two to three minutes and supports up to five selector rules per profile.
Create a Fargate profile on cluster prod-eu that selects pods in the batch namespace with label workload=etl.
Add-on Lifecycle Management
EKS add-ons let teams keep cluster components such as VPC CNI, CoreDNS, and kube-proxy on supported, vendor-curated versions. The API handles install, version updates, and removal so cluster operators can roll out coordinated upgrades across many clusters. Add-on updates are non-disruptive when configured with the PRESERVE conflict resolution strategy.
Update the vpc-cni add-on on cluster prod-eu to version v1.15.1-eksbuild.1 with the PRESERVE conflict resolution strategy.
Agent-Driven Cluster Operations via Jentic
AI agents use the EKS API through Jentic to handle routine cluster operations such as listing clusters, checking upgrade readiness, and provisioning new node groups in response to capacity events. Jentic exposes EKS operations as discoverable tools so an agent can search by intent and execute the matching operation without parsing AWS docs. This shortens incident response and capacity planning loops from manual console work to seconds.
Search Jentic for create cluster, load the EKS createCluster schema, and execute it for a new staging cluster in us-east-2.
Key Endpoints
35 endpoints — jentic publishes the only available openapi specification for amazon elastic kubernetes service, keeping it validated and agent-ready.
METHOD
PATH
DESCRIPTION
POST
/clusters
Create a new EKS cluster
GET
/clusters
List EKS clusters in the account
DELETE
/clusters/{name}
Delete an EKS cluster
POST
/clusters/{name}/node-groups
Create a managed node group
POST
/clusters/{name}/fargate-profiles
Create a Fargate profile
POST
/clusters/{name}/addons
Install an EKS add-on
POST
/clusters/{name}/identity-provider-configs/associate
Associate an OIDC identity provider
POST
/clusters
Create a new EKS cluster
GET
/clusters
List EKS clusters in the account
DELETE
/clusters/{name}
Delete an EKS cluster
POST
/clusters/{name}/node-groups
Create a managed node group
POST
/clusters/{name}/fargate-profiles
Create a Fargate profile
POST
/clusters/{name}/addons
Install an EKS add-on
POST
/clusters/{name}/identity-provider-configs/associate
Associate an OIDC identity provider
Jentic AI Readiness Score
This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.
A
Amazon Elastic Kubernetes Service
- AI-Aware (B-)61/100
99
Foundational Compliance58
Developer Experience & Jentic Compatibility39
AI-Readiness & Agent Experience94
Agent Usability50
Security100
AI DiscoverabilityPowered by JenticScoring Framework 1.0.0 | Scoring Engine 0.4.0
Show dimension breakdown
99
Foundational Compliance
Base layer of spec validity and structural soundness.
Grade: A+Signals: 4
96%
Lint Results
Aggregated quality score from linter diagnostics, weighted by severity.
100%
Resolution Completeness
Percentage of `$ref` references that resolve successfully.
100%
Specification Validity
Checks whether the API description parses successfully and conforms to its declared specification (e.g., OpenAPI).
100%
Structural Integrity
Structural correctness score based on schema issues using logarithmic dampening.
58
Developer Experience & Jentic Compatibility
Clarity, completeness, and ingestion readiness for developers and tooling.
Grade: C+Signals: 4
0%
Example Density
How richly the API is illustrated with examples.
80%
Example Validity
Percentage of examples that conform to their schemas.
50%
Response Coverage
Percentage of operations with complete response definitions (success, client error, server error).
100%
Tooling Readiness
Health of API ingestion, bundling, and resolution within Jentic pipelines.
39
AI-Readiness & Agent Experience
Semantic breadth, depth, and agent comprehension for AI systems.
Grade: FSignals: 4
55%
Description Coverage
Coverage of descriptions across API elements.
0%
Error Standardization
Coverage of RFC 9457 Problem Details for error responses.
100%
OperationId Quality
Coverage, uniqueness, and casing consistency of operationIds for AI inference.
0%
Summary Coverage
Coverage of summaries across operations/tags/info.
94
Agent Usability
Functional utility, complexity comfort, and AI orchestration readiness.
Grade: A+Signals: 1
94%
Complexity Comfort
Agent comfort level based on API operational and structural complexity.
50
Security
Trust, risk posture, and security compliance.
Grade: C-Signals: 1
50%
Authentication Strength
Average quality of security schemes based on authentication method strength (weakest link for OAuth2).
100
AI Discoverability
Findability, semantic richness, and reasoning readiness.
Grade: A+Signals: 1
100%
Descriptive Richness
Clarity and depth of descriptions across API elements.
Score it yourself
Every API in the directory is allowlisted, so you can re-score it with no key required.
npx @jentic/api-scorecard-cli score <openapi-url>Why Jentic?
What agents get from Jentic-routed access to this vendor.
Setup
Wiring Amazon EKS by hand means building SigV4 request signing, resolving the regional eks.{region}.amazonaws.com host, and handling AWS throttling and retries yourself. Through Jentic you install once, import EKS from the API Directory, store the AWS access keys once, and your agent calls it.
Permission scoping
EKS puts the cluster name in the URL path (/clusters/{name}/...), so a rule can pin your agent to one cluster: it can manage node groups, Fargate profiles, and add-ons for that cluster and nothing else. You choose the operations it may call, so cluster deletion is not included unless you add it.
Credential isolation
Your AWS access keys for EKS are stored once, encrypted, by your own Jentic One instance and injected at execution time when the request is signed. They never enter the agent's prompt, logs, or context.
Intent-based discovery
Agents search Jentic by intent such as 'provision a Kubernetes cluster' or 'add a managed node group', and Jentic returns the matching EKS operation with its input schema so the agent calls the right endpoint without browsing the reference docs.
Related APIs
Alternatives and complements available in the Jentic catalogue.
FAQs
Specific to using Amazon Elastic Kubernetes Service API through Jentic.
Why is there no official OpenAPI spec for Amazon Elastic Kubernetes Service?
AWS does not publish an OpenAPI specification. Jentic generates and maintains this spec so that AI agents and developers can call Amazon Elastic Kubernetes Service via structured tooling. It is validated against the live API and kept up to date. Get started with Jentic One, the self-hosted execution layer.
What authentication does the Amazon EKS API use?
EKS uses AWS Signature Version 4 request signing (the spec marks the scheme as hmac/apiKey). Through Jentic, AWS access keys are stored encrypted in the vault and signing happens server-side, so raw credentials never enter the agent context.
Can I create managed node groups with the EKS API?
Yes. POST /clusters/{name}/node-groups creates a managed node group with instance type, scaling configuration, AMI type, and Kubernetes labels. The cluster must already exist before you call this endpoint.
What are the rate limits for the Amazon EKS API?
AWS applies per-account, per-region API throttling on EKS. Mutating calls (create cluster, create node group) are limited more aggressively than describe calls. Use exponential backoff on ThrottlingException responses; AWS does not publish exact TPS numbers in the spec.
How do I install an EKS add-on through Jentic?
Search Jentic for install eks addon, load the schema for POST /clusters/{name}/addons, and execute it with the cluster name, addonName (for example vpc-cni), and addonVersion. Jentic returns the createdAt timestamp and add-on ARN once the call succeeds.
Does the EKS API let me run kubectl commands?
No. The EKS API manages the cluster control plane, node groups, and add-ons. Kubernetes object operations (kubectl apply, get pods) go directly to the cluster's Kubernetes API server using the kubeconfig you obtain from describeCluster.
Can I limit what my agent is allowed to do with the Amazon EKS API?
Yes. Because you run Jentic One yourself, your own rules decide which EKS operations and credentials the agent may use. Since EKS puts the cluster name in the URL path (/clusters/{name}/...), you can pin the agent to a single cluster so it manages that cluster's node groups, Fargate profiles, and add-ons and nothing else. You also choose the exact operations it may call, so destructive actions like deleting a cluster are excluded unless you explicitly allow them.
GET STARTED