@pulumi/awsx
Version:
[](https://github.com/pulumi/pulumi-awsx/actions) [](https://slack.pulumi.com) [ • 4.26 kB
TypeScript
import * as aws from "@pulumi/aws";
import * as pulumi from "@pulumi/pulumi";
import * as apigateway from "../apigateway";
import * as ec2 from "../ec2";
import { Listener } from "./listener";
import { TargetGroup, TargetType } from "./targetGroup";
export declare abstract class LoadBalancer extends pulumi.ComponentResource {
readonly loadBalancer: aws.lb.LoadBalancer;
readonly vpc: ec2.Vpc;
readonly securityGroups: ec2.SecurityGroup[];
readonly listeners: Listener[];
readonly targetGroups: TargetGroup[];
constructor(type: string, name: string, args: LoadBalancerArgs, opts: pulumi.ComponentResourceOptions);
/**
* Attaches a target to the first `listener` of this LoadBalancer. If there are multiple
* `listeners` you can add a target to specific listener to by calling `.attachTarget` directly
* on it.
*/
attachTarget(name: string, args: LoadBalancerTarget, opts?: pulumi.CustomResourceOptions): import("./targetGroupAttachment").TargetGroupAttachment;
}
export interface LoadBalancerArgs {
/**
* An existing aws.lb.LoadBalancer to use for this awsx.lb.LoadBalancer.
* If this value is set then all other arguments are ignored.
* If not provided, one will be created.
*/
loadBalancer?: aws.lb.LoadBalancer;
/**
* The vpc this load balancer will be used with. Defaults to `[Vpc.getDefault]` if
* unspecified.
*/
vpc?: ec2.Vpc;
/**
* @deprecated Not used. Supply the name you want for a LoadBalancer through the [name]
* constructor arg.
*/
name?: string;
/**
* Whether or not the load balancer is exposed to the internet. Defaults to `true` if
* unspecified.
*/
external?: boolean;
/**
* The type of load balancer to create. Possible values are `application` or `network`.
*/
loadBalancerType: pulumi.Input<"application" | "network">;
/**
* If true, deletion of the load balancer will be disabled via the AWS API. This will prevent
* Terraform from deleting the load balancer. Defaults to `false`.
*/
enableDeletionProtection?: pulumi.Input<boolean>;
/**
* The type of IP addresses used by the subnets for your load balancer. The possible values are
* `ipv4` and `dualstack`
*/
ipAddressType?: pulumi.Input<"ipv4" | "dualstack">;
/**
* The subnets to use for the load balancer. If not provided, the appropriate external or
* internal subnets of the [network] will be used.
*/
subnets?: pulumi.Input<pulumi.Input<string>[]> | LoadBalancerSubnets;
/**
* A subnet mapping block as documented below.
*/
subnetMappings?: aws.lb.LoadBalancerArgs["subnetMappings"];
/**
* A mapping of tags to assign to the resource.
*/
tags?: pulumi.Input<aws.Tags>;
/**
* A list of security group IDs to assign to the LB. Only valid for Load Balancers of type
* `application`.
*/
securityGroups?: ec2.SecurityGroupOrId[];
}
export interface LoadBalancerSubnets {
subnets(): pulumi.Input<pulumi.Input<string>[]>;
}
export interface LoadBalancerTargetInfo {
/**
* The ID of the target. This is the Instance ID for an `instance`, or the container ID for an
* ECS container. If the target type is `ip`, specify an IP address. If the target type is
* `lambda`, specify the arn of lambda.
*/
targetId: string;
/**
* The Availability Zone where the IP address of the target is to be registered.
*/
availabilityZone?: string;
/**
* The port on which targets receive traffic.
*/
port?: number;
}
export interface LoadBalancerTargetInfoProvider {
loadBalancerTargetInfo(targetType: pulumi.Input<TargetType>): pulumi.Output<LoadBalancerTargetInfo>;
}
export declare function isLoadBalancerTargetInfoProvider(obj: any): obj is LoadBalancerTargetInfoProvider;
/**
* The types of things that can be the target of a load balancer.
*
* Note: A lambda event handler can only be supplied if using an application load balancer.
*/
export type LoadBalancerTarget = pulumi.Input<LoadBalancerTargetInfo> | LoadBalancerTargetInfoProvider | aws.ec2.Instance | aws.lambda.EventHandler<apigateway.Request, apigateway.Response>;