canonical: https://jentic.com/apis/amazonaws.com/elastic-load-balancing-v2

# AWS Elastic Load Balancing

Jentic publishes the only available OpenAPI specification for Elastic Load Balancing, keeping it validated and agent-ready. Elastic Load Balancing v2 covers Application, Network, and Gateway Load Balancers on AWS. The API manages load balancer creation, listeners, routing rules, target groups, target registration, and health checks across multiple Availability Zones. It is built for platform and SRE teams that need to programmatically expose services, shift traffic between target groups, and roll out blue-green or weighted deployments without console interaction.

## For AI agents

Create Application, Network, and Gateway Load Balancers, manage listeners and routing rules, and register targets across AWS regions through a single API.

## Scope

Does not handle Classic Load Balancers, DNS records, or WAF rules - use for Application, Network, and Gateway Load Balancer management only.

## Capabilities

- Create Application, Network, and Gateway Load Balancers across multiple Availability Zones
- Define listeners and listener rules with path, host, header, and source IP conditions
- Register and deregister EC2 instances, IP targets, and Lambda functions in target groups
- Configure target group health checks, deregistration delay, and stickiness attributes
- Attach ACM certificates to HTTPS listeners and manage SNI certificate sets
- Modify routing rule priorities and actions to support weighted blue-green traffic shifting
- Tag load balancers, target groups, and listeners for cost allocation and discovery

## Use cases

### Application Load Balancer Provisioning

Platform teams use the Elastic Load Balancing API to provision Application Load Balancers in front of containerised services and EC2 fleets. The API drives load balancer creation, listener setup, target group registration, and health-check configuration so that infrastructure pipelines can stand up internet-facing or internal endpoints without console steps. A standard ALB with two listeners and three target groups can be provisioned in under five minutes when run as an automated workflow.

Example prompt: Create an internet-facing Application Load Balancer in subnets subnet-a and subnet-b, then attach an HTTPS listener forwarding to target group api-prod.

### Blue-Green and Canary Traffic Shifting

Deployment systems use ELBv2 listener rules with weighted target groups to shift traffic between blue and green stacks during release. The API lets a release controller adjust forward action weights from 100/0 to 90/10 to 50/50 in seconds, with rollback by reversing the same call. Health-check signals on each target group gate the next traffic step.

Example prompt: Modify the listener rule on listener arn:...:listener/app/prod/abc to forward 90 percent to target group blue and 10 percent to target group green.

### Target Health Monitoring

Reliability teams use the API to read target health states across hundreds of target groups in response to incidents and scaling events. The DescribeTargetHealth call returns per-target state, reason codes, and descriptions so that runbooks can pinpoint failing instances before paging humans. The same API powers automated remediation that deregisters chronically unhealthy targets and triggers replacement via Auto Scaling.

Example prompt: List all targets in target group prod-api with state unhealthy and return the reason code and description for each.

### Agent-Driven Load Balancer Operations via Jentic

AI agents use the ELBv2 API through Jentic to perform routine traffic operations such as registering new targets after a deploy, updating listener rules, and rotating TLS certificates. Jentic exposes ELBv2 operations as discoverable tools so an agent can search by intent and execute the matching call without parsing AWS docs. This compresses release-time traffic management from manual console work to a single agent action.

Example prompt: Search Jentic for register target with load balancer, load the RegisterTargets schema, and execute it for instance i-0123456789abcdef0 in target group api-prod.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | /#Action=CreateLoadBalancer | Create a load balancer |
| POST | /#Action=CreateListener | Create a listener on a load balancer |
| POST | /#Action=CreateTargetGroup | Create a target group |
| POST | /#Action=CreateRule | Create a listener rule |
| POST | /#Action=DeleteLoadBalancer | Delete a load balancer |
| POST | /#Action=AddListenerCertificates | Add TLS certificates to a listener |
| POST | /#Action=AddTags | Tag load balancers and target groups |

## Key resources

- **Load Balancers** — Create, describe, and delete Application, Network, and Gateway Load Balancers
- **Listeners** — Configure protocol, port, and default actions for incoming connections
- **Listener Rules** — Define routing rules with path, host, header, and source IP conditions
- **Target Groups** — Group targets and configure health checks, stickiness, and attributes
- **Targets** — Register and deregister EC2 instances, IP addresses, and Lambda functions

## Why Jentic

- **Setup:** Wiring Elastic Load Balancing by hand means building SigV4 request signing, resolving the regional elasticloadbalancing.{region}.amazonaws.com host, and handling the query-style Action dispatch plus AWS retries yourself. Through Jentic you install once, import Elastic Load Balancing from the API Directory, store the AWS access keys once, and your agent calls it.
- **Permission scoping:** Elastic Load Balancing dispatches every action through a single endpoint with the operation named in the request, so scope the agent to the operations it needs, such as creating a load balancer, listener, or target group. Destructive operations like deleting a load balancer stay out of that set unless you add them.
- **Credential handling:** Your AWS access keys for Elastic Load Balancing 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.
- **Discovery method:** Agents search Jentic by intent such as 'create a load balancer' or 'register a target group', and Jentic returns the matching Elastic Load Balancing operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Amazon EC2** — EC2 provides the instances that ELBv2 registers as targets
- **Amazon EKS** — Runs Kubernetes services that are typically exposed via ALB or NLB
- **Amazon Route 53** — Maps human-readable DNS names to ELBv2 load balancer endpoints

## FAQ

### Why is there no official OpenAPI spec for Elastic Load Balancing?

AWS does not publish an OpenAPI specification. Jentic generates and maintains this spec so that AI agents and developers can call Elastic Load Balancing 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 Elastic Load Balancing API use?

ELBv2 uses AWS Signature Version 4 request signing. Through Jentic, AWS access keys are stored encrypted in the vault and signing happens server-side, so the raw secret access key never reaches the agent.

### Can I shift traffic between target groups with this API?

Yes. ModifyListener and ModifyRule accept a forward action with multiple TargetGroups and per-group Weight values. Adjusting weights live lets you implement blue-green and canary patterns without recreating the listener.

### What are the rate limits for the Elastic Load Balancing API?

AWS applies per-account, per-region throttling. Mutating calls such as CreateLoadBalancer and CreateRule are throttled more aggressively than Describe calls. Use exponential backoff on ThrottlingException responses; AWS does not publish exact TPS numbers in the spec.

### How do I register a target with a target group through Jentic?

Search Jentic for register targets, load the schema for the RegisterTargets action, and execute it with the TargetGroupArn and a Targets array containing instance IDs or IP addresses. Jentic returns the call result once registration completes.

### Does the ELBv2 API manage Classic Load Balancers?

No. This v2 API covers Application, Network, and Gateway Load Balancers. Classic Load Balancers use the older elasticloadbalancing v1 API, which is a separate service with different action names.

### Can I limit what my agent is allowed to do with the Elastic Load Balancing API?

Yes. Because Elastic Load Balancing dispatches every action through a single endpoint with the operation named in the request, your self-hosted Jentic One instance lets you scope the agent to only the operations it needs, such as CreateLoadBalancer, CreateListener, or CreateTargetGroup. Your own rules decide which operations and AWS credentials the agent may use, so destructive calls like DeleteLoadBalancer stay out of the agent's allowed set unless you add them. This means an agent registering targets or shifting traffic never gains the ability to tear down a load balancer.