314 lines
9.0 KiB
TypeScript
314 lines
9.0 KiB
TypeScript
import type { Construct } from 'constructs';
|
|
import { CfnLoadBalancer } from './elasticloadbalancing.generated';
|
|
import type { IConnectable, Instance, ISecurityGroup, IVpc, SubnetSelection } from '../../aws-ec2';
|
|
import { Connections, Port } from '../../aws-ec2';
|
|
import type { IResource } from '../../core';
|
|
import { Duration, Resource } from '../../core';
|
|
import type { aws_elasticloadbalancing } from '../../interfaces';
|
|
/**
|
|
* Represents a load balancer
|
|
*/
|
|
export interface ILoadBalancer extends IResource, aws_elasticloadbalancing.ILoadBalancerRef {
|
|
}
|
|
/**
|
|
* Construction properties for a LoadBalancer
|
|
*/
|
|
export interface LoadBalancerProps {
|
|
/**
|
|
* VPC network of the fleet instances
|
|
*/
|
|
readonly vpc: IVpc;
|
|
/**
|
|
* Whether this is an internet-facing Load Balancer
|
|
*
|
|
* This controls whether the LB has a public IP address assigned. It does
|
|
* not open up the Load Balancer's security groups to public internet access.
|
|
*
|
|
* @default false
|
|
*/
|
|
readonly internetFacing?: boolean;
|
|
/**
|
|
* What listeners to set up for the load balancer.
|
|
*
|
|
* Can also be added by .addListener()
|
|
*
|
|
* @default -
|
|
*/
|
|
readonly listeners?: LoadBalancerListener[];
|
|
/**
|
|
* What targets to load balance to.
|
|
*
|
|
* Can also be added by .addTarget()
|
|
*
|
|
* @default - None.
|
|
*/
|
|
readonly targets?: ILoadBalancerTarget[];
|
|
/**
|
|
* Health check settings for the load balancing targets.
|
|
*
|
|
* Not required but recommended.
|
|
*
|
|
* @default - None.
|
|
*/
|
|
readonly healthCheck?: HealthCheck;
|
|
/**
|
|
* Whether cross zone load balancing is enabled
|
|
*
|
|
* This controls whether the load balancer evenly distributes requests
|
|
* across each availability zone
|
|
*
|
|
* @default true
|
|
*/
|
|
readonly crossZone?: boolean;
|
|
/**
|
|
* Which subnets to deploy the load balancer
|
|
*
|
|
* Can be used to define a specific set of subnets to deploy the load balancer to.
|
|
* Useful multiple public or private subnets are covering the same availability zone.
|
|
*
|
|
* @default - Public subnets if internetFacing, Private subnets otherwise
|
|
*/
|
|
readonly subnetSelection?: SubnetSelection;
|
|
/**
|
|
* Enable Loadbalancer access logs
|
|
* Can be used to avoid manual work as aws console
|
|
* Required S3 bucket name , enabled flag
|
|
* Can add interval for pushing log
|
|
* Can set bucket prefix in order to provide folder name inside bucket
|
|
* @default - disabled
|
|
*/
|
|
readonly accessLoggingPolicy?: CfnLoadBalancer.AccessLoggingPolicyProperty;
|
|
}
|
|
/**
|
|
* Describe the health check to a load balancer
|
|
*/
|
|
export interface HealthCheck {
|
|
/**
|
|
* What port number to health check on
|
|
*/
|
|
readonly port: number;
|
|
/**
|
|
* What protocol to use for health checking
|
|
*
|
|
* The protocol is automatically determined from the port if it's not supplied.
|
|
*
|
|
* @default Automatic
|
|
*/
|
|
readonly protocol?: LoadBalancingProtocol;
|
|
/**
|
|
* What path to use for HTTP or HTTPS health check (must return 200)
|
|
*
|
|
* For SSL and TCP health checks, accepting connections is enough to be considered
|
|
* healthy.
|
|
*
|
|
* @default "/"
|
|
*/
|
|
readonly path?: string;
|
|
/**
|
|
* After how many successful checks is an instance considered healthy
|
|
*
|
|
* @default 2
|
|
*/
|
|
readonly healthyThreshold?: number;
|
|
/**
|
|
* After how many unsuccessful checks is an instance considered unhealthy
|
|
*
|
|
* @default 5
|
|
*/
|
|
readonly unhealthyThreshold?: number;
|
|
/**
|
|
* Number of seconds between health checks
|
|
*
|
|
* @default Duration.seconds(30)
|
|
*/
|
|
readonly interval?: Duration;
|
|
/**
|
|
* Health check timeout
|
|
*
|
|
* @default Duration.seconds(5)
|
|
*/
|
|
readonly timeout?: Duration;
|
|
}
|
|
/**
|
|
* Interface that is going to be implemented by constructs that you can load balance to
|
|
*/
|
|
export interface ILoadBalancerTarget extends IConnectable {
|
|
/**
|
|
* Attach load-balanced target to a classic ELB
|
|
* @param loadBalancer [disable-awslint:ref-via-interface] The load balancer to attach the target to
|
|
*/
|
|
attachToClassicLB(loadBalancer: LoadBalancer): void;
|
|
}
|
|
/**
|
|
* Add a backend to the load balancer
|
|
*/
|
|
export interface LoadBalancerListener {
|
|
/**
|
|
* External listening port
|
|
*/
|
|
readonly externalPort: number;
|
|
/**
|
|
* What public protocol to use for load balancing
|
|
*
|
|
* Either 'tcp', 'ssl', 'http' or 'https'.
|
|
*
|
|
* May be omitted if the external port is either 80 or 443.
|
|
*/
|
|
readonly externalProtocol?: LoadBalancingProtocol;
|
|
/**
|
|
* Instance listening port
|
|
*
|
|
* Same as the externalPort if not specified.
|
|
*
|
|
* @default externalPort
|
|
*/
|
|
readonly internalPort?: number;
|
|
/**
|
|
* What public protocol to use for load balancing
|
|
*
|
|
* Either 'tcp', 'ssl', 'http' or 'https'.
|
|
*
|
|
* May be omitted if the internal port is either 80 or 443.
|
|
*
|
|
* The instance protocol is 'tcp' if the front-end protocol
|
|
* is 'tcp' or 'ssl', the instance protocol is 'http' if the
|
|
* front-end protocol is 'https'.
|
|
*/
|
|
readonly internalProtocol?: LoadBalancingProtocol;
|
|
/**
|
|
* SSL policy names
|
|
*/
|
|
readonly policyNames?: string[];
|
|
/**
|
|
* the ARN of the SSL certificate
|
|
*
|
|
* @default - none
|
|
*/
|
|
readonly sslCertificateArn?: string;
|
|
/**
|
|
* Allow connections to the load balancer from the given set of connection peers
|
|
*
|
|
* By default, connections will be allowed from anywhere. Set this to an empty list
|
|
* to deny connections, or supply a custom list of peers to allow connections from
|
|
* (IP ranges or security groups).
|
|
*
|
|
* @default Anywhere
|
|
*/
|
|
readonly allowConnectionsFrom?: IConnectable[];
|
|
}
|
|
export declare enum LoadBalancingProtocol {
|
|
TCP = "tcp",
|
|
SSL = "ssl",
|
|
HTTP = "http",
|
|
HTTPS = "https"
|
|
}
|
|
/**
|
|
* A load balancer with a single listener
|
|
*
|
|
* Routes to a fleet of instances in a VPC.
|
|
*/
|
|
export declare class LoadBalancer extends Resource implements ILoadBalancer, IConnectable {
|
|
/**
|
|
* Uniquely identifies this class.
|
|
*/
|
|
static readonly PROPERTY_INJECTION_ID: string;
|
|
/**
|
|
* Control all connections from and to this load balancer
|
|
*/
|
|
readonly connections: Connections;
|
|
/**
|
|
* An object controlling specifically the connections for each listener added to this load balancer
|
|
*/
|
|
readonly listenerPorts: ListenerPort[];
|
|
private readonly elb;
|
|
private readonly securityGroup;
|
|
private readonly _listeners;
|
|
private readonly instancePorts;
|
|
private readonly targets;
|
|
private readonly _instanceIds;
|
|
constructor(scope: Construct, id: string, props: LoadBalancerProps);
|
|
/**
|
|
* Add a backend to the load balancer
|
|
*
|
|
* @returns A ListenerPort object that controls connections to the listener port
|
|
*/
|
|
addListener(listener: LoadBalancerListener): ListenerPort;
|
|
addTarget(target: ILoadBalancerTarget): void;
|
|
/**
|
|
* @attribute
|
|
*/
|
|
get loadBalancerName(): string;
|
|
/**
|
|
* @attribute
|
|
*/
|
|
get loadBalancerCanonicalHostedZoneNameId(): string;
|
|
/**
|
|
* @attribute
|
|
*/
|
|
get loadBalancerCanonicalHostedZoneName(): string;
|
|
/**
|
|
* @attribute
|
|
*/
|
|
get loadBalancerDnsName(): string;
|
|
/**
|
|
* @attribute
|
|
*/
|
|
get loadBalancerSourceSecurityGroupGroupName(): string;
|
|
/**
|
|
* @attribute
|
|
*/
|
|
get loadBalancerSourceSecurityGroupOwnerAlias(): string;
|
|
/**
|
|
* A reference to this LoadBalancer resource
|
|
*/
|
|
get loadBalancerRef(): aws_elasticloadbalancing.LoadBalancerReference;
|
|
/**
|
|
* Allow connections to all existing targets on new instance port
|
|
*/
|
|
private newInstancePort;
|
|
/**
|
|
* Allow connections to target on all existing instance ports
|
|
*/
|
|
private newTarget;
|
|
/**
|
|
* Allow connections for a single (port, target) pair
|
|
*/
|
|
private allowTargetConnection;
|
|
/**
|
|
* Add instance to the load balancer.
|
|
* @internal
|
|
*/
|
|
_addInstanceId(instanceId: string): void;
|
|
}
|
|
/**
|
|
* An EC2 instance that is the target for load balancing
|
|
*/
|
|
export declare class InstanceTarget implements ILoadBalancerTarget {
|
|
readonly instance: Instance;
|
|
readonly connections: Connections;
|
|
/**
|
|
* Create a new Instance target.
|
|
*
|
|
* @param instance Instance to register to.
|
|
*/
|
|
constructor(instance: Instance);
|
|
attachToClassicLB(loadBalancer: LoadBalancer): void;
|
|
}
|
|
/**
|
|
* Reference to a listener's port just created.
|
|
*
|
|
* This implements IConnectable with a default port (the port that an ELB
|
|
* listener was just created on) for a given security group so that it can be
|
|
* conveniently used just like any Connectable. E.g:
|
|
*
|
|
* const listener = elb.addListener(...);
|
|
*
|
|
* listener.connections.allowDefaultPortFromAnyIPv4();
|
|
* // or
|
|
* instance.connections.allowToDefaultPort(listener);
|
|
*/
|
|
export declare class ListenerPort implements IConnectable {
|
|
readonly connections: Connections;
|
|
constructor(securityGroup: ISecurityGroup, defaultPort: Port);
|
|
}
|