Hay más ejemplos de AWS SDK disponibles en el GitHub repositorio de [ejemplos de AWS Doc SDK](https://github.com/awsdocs/aws-doc-sdk-examples).
Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Úselo `CreateLoadBalancer` con un AWS SDK o CLI
Los siguientes ejemplos de código muestran cómo utilizar `CreateLoadBalancer`.
Los ejemplos de acciones son extractos de código de programas más grandes y deben ejecutarse en contexto. Puede ver esta acción en contexto en los siguientes ejemplos de código:
+ [Creación y administración de un servicio resiliente](elastic-load-balancing-v2_example_cross_ResilientService_section.md)
+ [Introducción a Elastic Load Balancing](elastic-load-balancing-v2_example_elastic_load_balancing_v2_GettingStarted_058_section.md)
------
#### [ .NET ]
**SDK para .NET**
Hay más información GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv3/cross-service/ResilientService/ElasticLoadBalancerActions#code-examples).
```
///
/// Create an Elastic Load Balancing load balancer that uses the specified subnets
/// and forwards requests to the specified target group.
///
/// The name for the new load balancer.
/// Subnets for the load balancer.
/// Target group for forwarded requests.
/// The new LoadBalancer object.
public async Task CreateLoadBalancerAndListener(string name, List subnetIds, TargetGroup targetGroup)
{
var createLbResponse = await _amazonElasticLoadBalancingV2.CreateLoadBalancerAsync(
new CreateLoadBalancerRequest()
{
Name = name,
Subnets = subnetIds
});
var loadBalancerArn = createLbResponse.LoadBalancers[0].LoadBalancerArn;
// Wait for load balancer to be available.
var loadBalancerReady = false;
while (!loadBalancerReady)
{
try
{
var describeResponse =
await _amazonElasticLoadBalancingV2.DescribeLoadBalancersAsync(
new DescribeLoadBalancersRequest()
{
Names = new List() { name }
});
var loadBalancerState = describeResponse.LoadBalancers[0].State.Code;
loadBalancerReady = loadBalancerState == LoadBalancerStateEnum.Active;
}
catch (LoadBalancerNotFoundException)
{
loadBalancerReady = false;
}
Thread.Sleep(10000);
}
// Create the listener.
await _amazonElasticLoadBalancingV2.CreateListenerAsync(
new CreateListenerRequest()
{
LoadBalancerArn = loadBalancerArn,
Protocol = targetGroup.Protocol,
Port = targetGroup.Port,
DefaultActions = new List()
{
new Action()
{
Type = ActionTypeEnum.Forward,
TargetGroupArn = targetGroup.TargetGroupArn
}
}
});
return createLbResponse.LoadBalancers[0];
}
```
+ Para obtener más información sobre la API, consulta [CreateLoadBalancer](https://docs.aws.amazon.com/goto/DotNetSDKV3/elasticloadbalancingv2-2015-12-01/CreateLoadBalancer)la *Referencia AWS SDK para .NET de la API*.
------
#### [ CLI ]
**AWS CLI**
**Ejemplo 1: creación de un equilibrador de carga expuesto a Internet**
En el siguiente ejemplo de `create-load-balancer` se crea un equilibrador de carga de aplicación expuesto a Internet y se habilitan las zonas de disponibilidad para las subredes especificadas.
```
aws elbv2 create-load-balancer \
--name {{my-load-balancer}} \
--subnets {{subnet-b7d581c0}} {{subnet-8360a9e7}}
```
Salida:
```
{
"LoadBalancers": [
{
"Type": "application",
"Scheme": "internet-facing",
"IpAddressType": "ipv4",
"VpcId": "vpc-3ac0fb5f",
"AvailabilityZones": [
{
"ZoneName": "us-west-2a",
"SubnetId": "subnet-8360a9e7"
},
{
"ZoneName": "us-west-2b",
"SubnetId": "subnet-b7d581c0"
}
],
"CreatedTime": "2017-08-25T21:26:12.920Z",
"CanonicalHostedZoneId": "Z2P70J7EXAMPLE",
"DNSName": "my-load-balancer-424835706.us-west-2.elb.amazonaws.com",
"SecurityGroups": [
"sg-5943793c"
],
"LoadBalancerName": "my-load-balancer",
"State": {
"Code": "provisioning"
},
"LoadBalancerArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-load-balancer/50dc6c495c0c9188"
}
]
}
```
Para obtener más información, consulte el [tutorial: Creación de un balanceador de carga de aplicaciones mediante la AWS CLI](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/tutorial-application-load-balancer-cli.html) en la *Guía del usuario de balanceadores de carga de aplicaciones*.
**Ejemplo 2: Creación de un equilibrador de carga interno**
En el siguiente ejemplo de `create-load-balancer` se crea un equilibrador de carga de aplicación interno y se habilitan las zonas de disponibilidad para las subredes especificadas.
```
aws elbv2 create-load-balancer \
--name {{my-internal-load-balancer}} \
--scheme {{internal}} \
--subnets {{subnet-b7d581c0}} {{subnet-8360a9e7}}
```
Salida:
```
{
"LoadBalancers": [
{
"Type": "application",
"Scheme": "internal",
"IpAddressType": "ipv4",
"VpcId": "vpc-3ac0fb5f",
"AvailabilityZones": [
{
"ZoneName": "us-west-2a",
"SubnetId": "subnet-8360a9e7"
},
{
"ZoneName": "us-west-2b",
"SubnetId": "subnet-b7d581c0"
}
],
"CreatedTime": "2016-03-25T21:29:48.850Z",
"CanonicalHostedZoneId": "Z2P70J7EXAMPLE",
"DNSName": "internal-my-internal-load-balancer-1529930873.us-west-2.elb.amazonaws.com",
"SecurityGroups": [
"sg-5943793c"
],
"LoadBalancerName": "my-internal-load-balancer",
"State": {
"Code": "provisioning"
},
"LoadBalancerArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-internal-load-balancer/5b49b8d4303115c2"
}
]
}
```
Para obtener más información, consulte el [tutorial: Creación de un balanceador de carga de aplicaciones mediante la AWS CLI](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/tutorial-application-load-balancer-cli.html) en la *Guía del usuario de balanceadores de carga de aplicaciones*.
**Ejemplo 3: creación de un equilibrador de carga de red**
En el siguiente ejemplo de `create-load-balancer` se crea un equilibrador de carga de red expuesto a Internet y se habilitan las zonas de disponibilidad para la subred especificada. Utiliza un mapeo de subred para asociar la dirección IP elástica especificada con la interfaz de red utilizada por los nodos del equilibrador de carga de la zona de disponibilidad.
```
aws elbv2 create-load-balancer \
--name {{my-network-load-balancer}} \
--type {{network}} \
--subnet-mappings {{SubnetId=subnet-b7d581c0,AllocationId=eipalloc-64d5890a}}
```
Salida:
```
{
"LoadBalancers": [
{
"Type": "network",
"Scheme": "internet-facing",
"IpAddressType": "ipv4",
"VpcId": "vpc-3ac0fb5f",
"AvailabilityZones": [
{
"LoadBalancerAddresses": [
{
"IpAddress": "35.161.207.171",
"AllocationId": "eipalloc-64d5890a"
}
],
"ZoneName": "us-west-2b",
"SubnetId": "subnet-5264e837"
}
],
"CreatedTime": "2017-10-15T22:41:25.657Z",
"CanonicalHostedZoneId": "Z2P70J7EXAMPLE",
"DNSName": "my-network-load-balancer-5d1b75f4f1cee11e.elb.us-west-2.amazonaws.com",
"LoadBalancerName": "my-network-load-balancer",
"State": {
"Code": "provisioning"
},
"LoadBalancerArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/net/my-network-load-balancer/5d1b75f4f1cee11e"
}
]
}
```
Para obtener más información, consulte el [tutorial: Creación de un balanceador de carga de red mediante la AWS CLI en la *Guía del usuario de Network Load* Balancers](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/network-load-balancer-cli.html).
**Ejemplo 4: creación de un equilibrador de carga de puerta de enlace**
En el siguiente ejemplo de `create-load-balancer` se crea un equilibrador de carga de puerta de enlace y se habilitan las zonas de disponibilidad para las subredes especificadas.
```
aws elbv2 create-load-balancer \
--name {{my-gateway-load-balancer}} \
--type {{gateway}} \
--subnets {{subnet-dc83f691}} {{subnet-a62583f9}}
```
Salida:
```
{
"LoadBalancers": [
{
"Type": "gateway",
"VpcId": "vpc-838475fe",
"AvailabilityZones": [
{
"ZoneName": "us-east-1b",
"SubnetId": "subnet-a62583f9"
},
{
"ZoneName": "us-east-1a",
"SubnetId": "subnet-dc83f691"
}
],
"CreatedTime": "2021-07-14T19:33:43.324000+00:00",
"LoadBalancerName": "my-gateway-load-balancer",
"State": {
"Code": "provisioning"
},
"LoadBalancerArn": "arn:aws:elasticloadbalancing:us-east-1:850631746142:loadbalancer/gwy/my-gateway-load-balancer/dfbb5a7d32cdee79"
}
]
}
```
Para obtener más información, consulte [Introducción a los balanceadores de carga de puerta de enlace mediante la AWS CLI en la](https://docs.aws.amazon.com/elasticloadbalancing/latest/gateway/getting-started-cli.html) *Guía del usuario de balanceadores de carga de puerta* de enlace.
+ Para obtener más información sobre la API, consulte la Referencia [CreateLoadBalancer](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/create-load-balancer.html)de *AWS CLI comandos*.
------
#### [ Java ]
**SDK para Java 2.x**
Hay más información al respecto GitHub. Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/usecases/resilient_service#code-examples).
```
/*
* Creates an Elastic Load Balancing load balancer that uses the specified
* subnets
* and forwards requests to the specified target group.
*/
public String createLoadBalancer(List subnetIds, String targetGroupARN, String lbName, int port,
String protocol) {
try {
List subnetIdStrings = subnetIds.stream()
.map(Subnet::subnetId)
.collect(Collectors.toList());
CreateLoadBalancerRequest balancerRequest = CreateLoadBalancerRequest.builder()
.subnets(subnetIdStrings)
.name(lbName)
.scheme("internet-facing")
.build();
// Create and wait for the load balancer to become available.
CreateLoadBalancerResponse lsResponse = getLoadBalancerClient().createLoadBalancer(balancerRequest);
String lbARN = lsResponse.loadBalancers().get(0).loadBalancerArn();
ElasticLoadBalancingV2Waiter loadBalancerWaiter = getLoadBalancerClient().waiter();
DescribeLoadBalancersRequest request = DescribeLoadBalancersRequest.builder()
.loadBalancerArns(lbARN)
.build();
System.out.println("Waiting for Load Balancer " + lbName + " to become available.");
WaiterResponse waiterResponse = loadBalancerWaiter
.waitUntilLoadBalancerAvailable(request);
waiterResponse.matched().response().ifPresent(System.out::println);
System.out.println("Load Balancer " + lbName + " is available.");
// Get the DNS name (endpoint) of the load balancer.
String lbDNSName = lsResponse.loadBalancers().get(0).dnsName();
System.out.println("*** Load Balancer DNS Name: " + lbDNSName);
// Create a listener for the load balance.
Action action = Action.builder()
.targetGroupArn(targetGroupARN)
.type("forward")
.build();
CreateListenerRequest listenerRequest = CreateListenerRequest.builder()
.loadBalancerArn(lsResponse.loadBalancers().get(0).loadBalancerArn())
.defaultActions(action)
.port(port)
.protocol(protocol)
.build();
getLoadBalancerClient().createListener(listenerRequest);
System.out.println("Created listener to forward traffic from load balancer " + lbName + " to target group "
+ targetGroupARN);
// Return the load balancer DNS name.
return lbDNSName;
} catch (ElasticLoadBalancingV2Exception e) {
e.printStackTrace();
}
return "";
}
```
+ Para obtener más información sobre la API, consulta [CreateLoadBalancer](https://docs.aws.amazon.com/goto/SdkForJavaV2/elasticloadbalancingv2-2015-12-01/CreateLoadBalancer)la *Referencia AWS SDK for Java 2.x de la API*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Hay más información. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/cross-services/wkflw-resilient-service#code-examples).
```
const client = new ElasticLoadBalancingV2Client({});
const { LoadBalancers } = await client.send(
new CreateLoadBalancerCommand({
Name: NAMES.loadBalancerName,
Subnets: state.subnets,
}),
);
state.loadBalancerDns = LoadBalancers[0].DNSName;
state.loadBalancerArn = LoadBalancers[0].LoadBalancerArn;
await waitUntilLoadBalancerAvailable(
{ client },
{ Names: [NAMES.loadBalancerName] },
);
```
+ Para obtener más información sobre la API, consulta [CreateLoadBalancer](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/elastic-load-balancing-v2/command/CreateLoadBalancerCommand)la *Referencia AWS SDK para JavaScript de la API*.
------
#### [ PowerShell ]
**Herramientas para la PowerShell versión 4**
**Ejemplo 1: Este ejemplo crea un nuevo equilibrador de carga de aplicación orientado a Internet con dos subredes.**
```
New-ELB2LoadBalancer -Type application -Scheme internet-facing -IpAddressType ipv4 -Name 'New-Test-ALB' -SecurityGroup 'sg-07c3414abb8811cbd' -subnet 'subnet-c37a67a6','subnet-fc02eea0'
```
**Salida:**
```
AvailabilityZones : {us-east-1b, us-east-1a}
CanonicalHostedZoneId : Z35SXDOTRQ7X7K
CreatedTime : 12/28/19 2:58:03 PM
DNSName : New-Test-ALB-1391502222.us-east-1.elb.amazonaws.com
IpAddressType : ipv4
LoadBalancerArn : arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/app/New-Test-ALB/dab2e4d90eb51493
LoadBalancerName : New-Test-ALB
Scheme : internet-facing
SecurityGroups : {sg-07c3414abb8811cbd}
State : Amazon.ElasticLoadBalancingV2.Model.LoadBalancerState
Type : application
VpcId : vpc-2cfd7000
```
+ Para obtener más información sobre la API, consulte [CreateLoadBalancer Herramientas de AWS para PowerShell](https://docs.aws.amazon.com/powershell/v4/reference)*Cmdlet Reference (V4)*.
**Herramientas para la versión 5 PowerShell **
**Ejemplo 1: Este ejemplo crea un nuevo equilibrador de carga de aplicación orientado a Internet con dos subredes.**
```
New-ELB2LoadBalancer -Type application -Scheme internet-facing -IpAddressType ipv4 -Name 'New-Test-ALB' -SecurityGroup 'sg-07c3414abb8811cbd' -subnet 'subnet-c37a67a6','subnet-fc02eea0'
```
**Salida:**
```
AvailabilityZones : {us-east-1b, us-east-1a}
CanonicalHostedZoneId : Z35SXDOTRQ7X7K
CreatedTime : 12/28/19 2:58:03 PM
DNSName : New-Test-ALB-1391502222.us-east-1.elb.amazonaws.com
IpAddressType : ipv4
LoadBalancerArn : arn:aws:elasticloadbalancing:us-east-1:123456789012:loadbalancer/app/New-Test-ALB/dab2e4d90eb51493
LoadBalancerName : New-Test-ALB
Scheme : internet-facing
SecurityGroups : {sg-07c3414abb8811cbd}
State : Amazon.ElasticLoadBalancingV2.Model.LoadBalancerState
Type : application
VpcId : vpc-2cfd7000
```
+ Para obtener más información sobre la API, consulte [CreateLoadBalancer](https://docs.aws.amazon.com/powershell/v5/reference)la *referencia de Herramientas de AWS para PowerShell cmdlets (*V5).
------
#### [ Python ]
**SDK para Python (Boto3)**
Hay más información sobre. GitHub Busque el ejemplo completo y aprenda a configurar y ejecutar en el [Repositorio de ejemplos de código de AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/elastic-load-balancing#code-examples).
```
class ElasticLoadBalancerWrapper:
"""Encapsulates Elastic Load Balancing (ELB) actions."""
def __init__(self, elb_client: boto3.client):
"""
Initializes the LoadBalancer class with the necessary parameters.
"""
self.elb_client = elb_client
def create_load_balancer(
self,
load_balancer_name: str,
subnet_ids: List[str],
) -> Dict[str, Any]:
"""
Creates an Elastic Load Balancing load balancer that uses the specified subnets
and forwards requests to the specified target group.
:param load_balancer_name: The name of the load balancer to create.
:param subnet_ids: A list of subnets to associate with the load balancer.
:return: Data about the newly created load balancer.
"""
try:
response = self.elb_client.create_load_balancer(
Name=load_balancer_name, Subnets=subnet_ids
)
load_balancer = response["LoadBalancers"][0]
log.info(f"Created load balancer '{load_balancer_name}'.")
waiter = self.elb_client.get_waiter("load_balancer_available")
log.info(
f"Waiting for load balancer '{load_balancer_name}' to be available..."
)
waiter.wait(Names=[load_balancer_name])
log.info(f"Load balancer '{load_balancer_name}' is now available!")
except ClientError as err:
error_code = err.response["Error"]["Code"]
log.error(
f"Failed to create load balancer '{load_balancer_name}'. Error code: {error_code}, Message: {err.response['Error']['Message']}"
)
if error_code == "DuplicateLoadBalancerNameException":
log.error(
f"A load balancer with the name '{load_balancer_name}' already exists. "
"Load balancer names must be unique within the AWS region. "
"Please choose a different name and try again."
)
if error_code == "TooManyLoadBalancersException":
log.error(
"The maximum number of load balancers has been reached in this account and region. "
"You can delete unused load balancers or request an increase in the service quota from AWS Support."
)
log.error(f"Full error:\n\t{err}")
else:
return load_balancer
```
+ Para obtener más información sobre la API, consulta [CreateLoadBalancer](https://docs.aws.amazon.com/goto/boto3/elasticloadbalancingv2-2015-12-01/CreateLoadBalancer)la *AWS Referencia de API de SDK for Python (Boto3*).
------