Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Elastic Load Balancing - Esempi di utilizzo della versione 2 AWS CLI
I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando AWS Command Line Interface with Elastic Load Balancing - Versione 2.
Le *azioni* sono estratti di codice da programmi più grandi e devono essere eseguite nel contesto. Sebbene le azioni mostrino come richiamare le singole funzioni del servizio, è possibile visualizzarle contestualizzate negli scenari correlati.
Ogni esempio include un link al codice sorgente completo, in cui vengono fornite le istruzioni su come configurare ed eseguire il codice nel contesto.
**Topics**
+ [Azioni](#actions)
## Azioni
### `add-listener-certificates`
Il seguente esempio di codice mostra come utilizzare`add-listener-certificates`.
**AWS CLI**
**Come aggiungere un certificato a un listener sicuro**
Questo esempio aggiunge il certificato specificato al listener sicuro specificato.
Comando:
```
aws elbv2 add-listener-certificates --listener-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:listener/app/my-load-balancer/50dc6c495c0c9188/f2f7dc8efc522ab2 --certificates CertificateArn=arn:aws:acm:us-west-2:123456789012:certificate/5cc54884-f4a3-4072-80be-05b9ba72f705
```
Output:
```
{
"Certificates": [
{
"CertificateArn": "arn:aws:acm:us-west-2:123456789012:certificate/5cc54884-f4a3-4072-80be-05b9ba72f705",
"IsDefault": false
}
]
}
```
+ Per i dettagli sull'API, consulta [AddListenerCertificates AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/add-listener-certificates.html)*Command Reference*.
### `add-tags`
Il seguente esempio di codice mostra come utilizzare`add-tags`.
**AWS CLI**
**Come aggiungere tag a un bilanciatore del carico**
L’esempio `add-tags` seguente aggiunge i tag `project` e `department` al bilanciatore del carico specificato.
```
aws elbv2 add-tags \
--resource-arns arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-load-balancer/50dc6c495c0c9188 \
--tags "Key=project,Value=lima" "Key=department,Value=digital-media"
```
+ Per i dettagli sull'API, consulta [AddTags AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/add-tags.html)*Command Reference*.
### `create-listener`
Il seguente esempio di codice mostra come utilizzare`create-listener`.
**AWS CLI**
**Esempio 1: come creare un listener HTTP**
L’esempio `create-listener` seguente crea un listener HTTP per l’Application Load Balancer specificato che inoltra le richieste al gruppo di destinazione specificato.
```
aws elbv2 create-listener \
--load-balancer-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-load-balancer/50dc6c495c0c9188 \
--protocol HTTP \
--port 80 \
--default-actions Type=forward,TargetGroupArn=arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-targets/73e2d6bc24d8a067
```
Per ulteriori informazioni, consulta [Tutorial: Create an Application Load Balancer usando la AWS CLI](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/tutorial-application-load-balancer-cli.html#create-load-balancer-aws-cli) nella *User Guide for* Application Load Balancers.
**Esempio 2: come creare un listener HTTPS**
L’esempio `create-listener` seguente crea un listener HTTPS per l’Application Load Balancer specificato che inoltra le richieste al gruppo di destinazione specificato. Devi specificare un certificato SSL per un listener HTTPS. È possibile creare e gestire certificati utilizzando AWS Certificate Manager (ACM). In alternativa, puoi creare un certificato utilizzando SSL/TLS strumenti, far firmare il certificato da un'autorità di certificazione (CA) e caricarlo su AWS Identity and Access Management (IAM).
```
aws elbv2 create-listener \
--load-balancer-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-load-balancer/50dc6c495c0c9188 \
--protocol HTTPS \
--port 443 \
--certificates CertificateArn=arn:aws:acm:us-west-2:123456789012:certificate/3dcb0a41-bd72-4774-9ad9-756919c40557 \
--ssl-policy ELBSecurityPolicy-2016-08 \
--default-actions Type=forward,TargetGroupArn=arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-targets/73e2d6bc24d8a067
```
Per ulteriori informazioni, consulta [Aggiunta di un listener HTTPS](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/tutorial-application-load-balancer-cli.html#https-listener-aws-cli) nella *Guida per l’utente di Application Load Balancer*.
**Esempio 3: come creare un listener TCP**
L’esempio `create-listener` seguente crea un listener TCP per il Network Load Balancer specificato che inoltra le richieste al gruppo di destinazione specificato.
```
aws elbv2 create-listener \
--load-balancer-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/net/my-network-load-balancer/5d1b75f4f1cee11e \
--protocol TCP \
--port 80 \
--default-actions Type=forward,TargetGroupArn=arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-tcp-targets/b6bba954d1361c78
```
Per ulteriori informazioni, consulta [Tutorial: Create a Network Load Balancer usando la AWS CLI](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/network-load-balancer-cli.html#create-load-balancer-aws-cli) nella *User Guide for* Network Load Balancer.
**Esempio 4: come creare un listener TLS**
L’esempio `create-listener` seguente crea un listener TLS per il Network Load Balancer specificato che inoltra le richieste al gruppo di destinazione specificato. È necessario specificare un certificato SSL per un listener TLS.
```
aws elbv2 create-listener \
--load-balancer-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-load-balancer/50dc6c495c0c9188 \
--protocol TLS \
--port 443 \
--certificates CertificateArn=arn:aws:acm:us-west-2:123456789012:certificate/3dcb0a41-bd72-4774-9ad9-756919c40557 \
--ssl-policy ELBSecurityPolicy-2016-08 \
--default-actions Type=forward,TargetGroupArn=arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-targets/73e2d6bc24d8a067
```
Per ulteriori informazioni, consulta [Listener TLS per il Network Load Balancer](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/create-tls-listener.html) nella *Guida per l’utente di Network Load Balancer*.
**Esempio 5: come creare un listener UDP**
L’esempio `create-listener` seguente crea un listener UDP per il Network Load Balancer specificato che inoltra le richieste al gruppo di destinazione specificato.
```
aws elbv2 create-listener \
--load-balancer-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/net/my-network-load-balancer/5d1b75f4f1cee11e \
--protocol UDP \
--port 53 \
--default-actions Type=forward,TargetGroupArn=arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-tcp-targets/b6bba954d1361c78
```
Per ulteriori informazioni, consulta [Tutorial: Create a Network Load Balancer usando la AWS CLI](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/network-load-balancer-cli.html#create-load-balancer-aws-cli) nella *User Guide for* Network Load Balancer.
**Esempio 6: come creare un listener per il gateway e l’inoltro specificati**
L’esempio `create-listener` seguente crea un listener per il Gateway Load Balancer specificato che inoltra le richieste al gruppo target specificato.
```
aws elbv2 create-listener \
--load-balancer-arn arn:aws:elasticloadbalancing:us-east-1:850631746142:loadbalancer/gwy/my-gateway-load-balancer/e0f9b3d5c7f7d3d6 \
--default-actions Type=forward,TargetGroupArn=arn:aws:elasticloadbalancing:us-east-1:850631746142:targetgroup/my-glb-targets/007ca469fae3bb1615
```
Output:
```
{
"Listeners": [
{
"ListenerArn": "arn:aws:elasticloadbalancing:us-east-1:850631746142:listener/gwy/my-agw-lb-example2/e0f9b3d5c7f7d3d6/afc127db15f925de",
"LoadBalancerArn": "arn:aws:elasticloadbalancing:us-east-1:850631746142:loadbalancer/gwy/my-agw-lb-example2/e0f9b3d5c7f7d3d6",
"DefaultActions": [
{
"Type": "forward",
"TargetGroupArn": "arn:aws:elasticloadbalancing:us-east-1:850631746142:targetgroup/test-tg-agw-2/007ca469fae3bb1615",
"ForwardConfig": {
"TargetGroups": [
{
"TargetGroupArn": "arn:aws:elasticloadbalancing:us-east-1:850631746142:targetgroup/test-tg-agw-2/007ca469fae3bb1615"
}
]
}
}
]
}
]
}
```
Per ulteriori informazioni, consulta [Guida introduttiva a Gateway Load Balancers using the AWS CLI](https://docs.aws.amazon.com/elasticloadbalancing/latest/gateway/getting-started-cli.html) nella *User Guide for* Gateway Load Balancers.
+ *Per i dettagli sull'API, consulta Command Reference. [CreateListener](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/create-listener.html)AWS CLI *
### `create-load-balancer`
Il seguente esempio di codice mostra come utilizzare`create-load-balancer`.
**AWS CLI**
**Esempio 1: come creare un bilanciatore del carico con connessione a Internet**
L’esempio `create-load-balancer` seguente crea un Application Load Balancer con connessione a Internet e abilita le zone di disponibilità per le sottoreti specificate.
```
aws elbv2 create-load-balancer \
--name my-load-balancer \
--subnets subnet-b7d581c0 subnet-8360a9e7
```
Output:
```
{
"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"
}
]
}
```
Per ulteriori informazioni, consulta [Tutorial: Create an Application Load Balancer usando la AWS CLI](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/tutorial-application-load-balancer-cli.html) nella *User Guide for* Application Load Balancers.
**Esempio 2: come creare un bilanciatore del carico interno**
L’esempio `create-load-balancer` seguente crea un Application Load Balancer interno e abilita le zone di disponibilità per le sottoreti specificate.
```
aws elbv2 create-load-balancer \
--name my-internal-load-balancer \
--scheme internal \
--subnets subnet-b7d581c0 subnet-8360a9e7
```
Output:
```
{
"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"
}
]
}
```
Per ulteriori informazioni, consulta [Tutorial: Create an Application Load Balancer usando la AWS CLI](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/tutorial-application-load-balancer-cli.html) nella *User Guide for* Application Load Balancers.
**Esempio 3: come creare un Network Load Balancer**
L’esempio `create-load-balancer` seguente crea un Network Load Balancer con connessione a Internet e abilita la zona di disponibilità per la sottorete specificata. Utilizza una mappatura delle sottoreti per associare l’indirizzo IP elastico specificato all’interfaccia di rete utilizzata dai nodi del bilanciatore del carico per la zona di disponibilità.
```
aws elbv2 create-load-balancer \
--name my-network-load-balancer \
--type network \
--subnet-mappings SubnetId=subnet-b7d581c0,AllocationId=eipalloc-64d5890a
```
Output:
```
{
"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"
}
]
}
```
Per ulteriori informazioni, consulta [Tutorial: Create a Network Load Balancer usando la AWS CLI](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/network-load-balancer-cli.html) nella *User Guide for* Network Load Balancer.
**Esempio 4: come creare un Gateway Load Balancer**
L’esempio `create-load-balancer` seguente crea un Gateway Load Balancer e abilita le zone di disponibilità per le sottoreti specificate.
```
aws elbv2 create-load-balancer \
--name my-gateway-load-balancer \
--type gateway \
--subnets subnet-dc83f691 subnet-a62583f9
```
Output:
```
{
"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"
}
]
}
```
Per ulteriori informazioni, consulta [Guida introduttiva a Gateway Load Balancers using the AWS CLI](https://docs.aws.amazon.com/elasticloadbalancing/latest/gateway/getting-started-cli.html) nella *User Guide for* Gateway Load Balancers.
+ *Per i dettagli sull'API, consulta Command Reference. [CreateLoadBalancer](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/create-load-balancer.html)AWS CLI *
### `create-rule`
Il seguente esempio di codice mostra come utilizzare`create-rule`.
**AWS CLI**
**Esempio 1: come creare una regola utilizzando una condizione di percorso e un’azione di inoltro**
L’esempio `create-rule` seguente crea una regola che inoltra le richieste al gruppo di destinazione se l’URL contiene lo schema specificato.
```
aws elbv2 create-rule \
--listener-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:listener/app/my-load-balancer/50dc6c495c0c9188/f2f7dc8efc522ab2 \
--priority 5 \
--conditions file://conditions-pattern.json
--actions Type=forward,TargetGroupArn=arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-targets/73e2d6bc24d8a067
```
Contenuto di `conditions-pattern.json`:
```
[
{
"Field": "path-pattern",
"PathPatternConfig": {
"Values": ["/images/*"]
}
}
]
```
**Esempio 2: come creare una regola utilizzando una condizione host e una risposta fissa**
L’esempio `create-rule` seguente crea una regola che fornisce una risposta fissa se il nome host nell’intestazione host corrisponde al nome host specificato.
```
aws elbv2 create-rule \
--listener-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:listener/app/my-load-balancer/50dc6c495c0c9188/f2f7dc8efc522ab2 \
--priority 10 \
--conditions file://conditions-host.json \
--actions file://actions-fixed-response.json
```
Contenuto di `conditions-host.json`
```
[
{
"Field": "host-header",
"HostHeaderConfig": {
"Values": ["*.example.com"]
}
}
]
```
Contenuto di `actions-fixed-response.json`
```
[
{
"Type": "fixed-response",
"FixedResponseConfig": {
"MessageBody": "Hello world",
"StatusCode": "200",
"ContentType": "text/plain"
}
}
]
```
**Esempio 3: come creare una regola utilizzando una condizione di indirizzo IP di origine, un’azione di autenticazione e un’azione di inoltro**
L’esempio `create-rule` seguente crea una regola che autentica l’utente se l’indirizzo IP di origine corrisponde all’indirizzo IP specificato e inoltra la richiesta al gruppo di destinazione specificato se l’autenticazione ha esito positivo.
```
aws elbv2 create-rule \
--listener-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:listener/app/my-load-balancer/50dc6c495c0c9188/f2f7dc8efc522ab2 \
--priority 20 \
--conditions file://conditions-source-ip.json \
--actions file://actions-authenticate.json
```
Contenuto di `conditions-source-ip.json`
```
[
{
"Field": "source-ip",
"SourceIpConfig": {
"Values": ["192.0.2.0/24", "198.51.100.10/32"]
}
}
]
```
Contenuto di `actions-authenticate.json`
```
[
{
"Type": "authenticate-oidc",
"AuthenticateOidcConfig": {
"Issuer": "https://idp-issuer.com",
"AuthorizationEndpoint": "https://authorization-endpoint.com",
"TokenEndpoint": "https://token-endpoint.com",
"UserInfoEndpoint": "https://user-info-endpoint.com",
"ClientId": "abcdefghijklmnopqrstuvwxyz123456789",
"ClientSecret": "123456789012345678901234567890",
"SessionCookieName": "my-cookie",
"SessionTimeout": 3600,
"Scope": "email",
"AuthenticationRequestExtraParams": {
"display": "page",
"prompt": "login"
},
"OnUnauthenticatedRequest": "deny"
},
"Order": 1
},
{
"Type": "forward",
"TargetGroupArn": "arn:aws:elasticloadbalancing:us-east-1:880185128111:targetgroup/cli-test/642a97ecb0e0f26b",
"Order": 2
}
]
```
+ Per i dettagli sull'API, consulta [CreateRule AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/create-rule.html)*Command Reference*.
### `create-target-group`
Il seguente esempio di codice mostra come utilizzare`create-target-group`.
**AWS CLI**
**Esempio 1: come creare un gruppo di destinazione per l’Application Load Balancer**
L’esempio `create-target-group` seguente crea un gruppo di destinazione per un Application Load Balancer in cui si registrano le destinazioni per ID istanza (il tipo di destinazione è `instance`). Questo gruppo di destinazione utilizza il protocollo HTTP, la porta 80 e le impostazioni di controllo dell’integrità predefinite per un gruppo di destinazione HTTP.
```
aws elbv2 create-target-group \
--name my-targets \
--protocol HTTP \
--port 80 \
--target-type instance \
--vpc-id vpc-3ac0fb5f
```
Output:
```
{
"TargetGroups": [
{
"TargetGroupArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-targets/73e2d6bc24d8a067",
"TargetGroupName": "my-targets",
"Protocol": "HTTP",
"Port": 80,
"VpcId": "vpc-3ac0fb5f",
"HealthCheckProtocol": "HTTP",
"HealthCheckPort": "traffic-port",
"HealthCheckEnabled": true,
"HealthCheckIntervalSeconds": 30,
"HealthCheckTimeoutSeconds": 5,
"HealthyThresholdCount": 5,
"UnhealthyThresholdCount": 2,
"HealthCheckPath": "/",
"Matcher": {
"HttpCode": "200"
},
"TargetType": "instance",
"ProtocolVersion": "HTTP1",
"IpAddressType": "ipv4"
}
]
}
```
Per ulteriori informazioni, consulta [Creazione di un gruppo di destinazione](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/create-target-group.html) nella *Guida per l’utente di Application Load Balancer*.
**Esempio 2: come creare un gruppo di destinazione per indirizzare il traffico da un Application Load Balancer a una funzione Lambda**
L’esempio `create-target-group` seguente crea un gruppo di destinazione per un Application Load Balancer in cui la destinazione è una funzione Lambda (il tipo di destinazione è `lambda`). Per impostazione predefinita, i controlli dell’integrità sono disabilitati per il gruppo di destinazione corrente.
```
aws elbv2 create-target-group \
--name my-lambda-target \
--target-type lambda
```
Output:
```
{
"TargetGroups": [
{
"TargetGroupArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-lambda-target/a3003e085dbb8ddc",
"TargetGroupName": "my-lambda-target",
"HealthCheckEnabled": false,
"HealthCheckIntervalSeconds": 35,
"HealthCheckTimeoutSeconds": 30,
"HealthyThresholdCount": 5,
"UnhealthyThresholdCount": 2,
"HealthCheckPath": "/",
"Matcher": {
"HttpCode": "200"
},
"TargetType": "lambda",
"IpAddressType": "ipv4"
}
]
}
```
Per ulteriori informazioni, consulta [Funzioni Lambda come destinazioni](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/lambda-functions.html) nella *Guida per l’utente di Application Load Balancer*.
**Esempio 3: come creare un gruppo di destinazione per il Network Load Balancer**
L’esempio `create-target-group` seguente crea un gruppo di destinazione per un Network Load Balancer in cui si registrano le destinazioni per indirizzo IP (il tipo di destinazione è `ip`). Questo gruppo di destinazione utilizza il protocollo TCP, la porta 80 e le impostazioni di controllo dell’integrità predefinite per un gruppo di destinazione TCP.
```
aws elbv2 create-target-group \
--name my-ip-targets \
--protocol TCP \
--port 80 \
--target-type ip \
--vpc-id vpc-3ac0fb5f
```
Output:
```
{
"TargetGroups": [
{
"TargetGroupArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-ip-targets/b6bba954d1361c78",
"TargetGroupName": "my-ip-targets",
"Protocol": "TCP",
"Port": 80,
"VpcId": "vpc-3ac0fb5f",
"HealthCheckEnabled": true,
"HealthCheckProtocol": "TCP",
"HealthCheckPort": "traffic-port",
"HealthCheckIntervalSeconds": 30,
"HealthCheckTimeoutSeconds": 10,
"HealthyThresholdCount": 5,
"UnhealthyThresholdCount": 2,
"TargetType": "ip",
"IpAddressType": "ipv4"
}
]
}
```
Per ulteriori informazioni, consulta [Creazione di un gruppo di destinazione](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/create-target-group.html) nella *Guida per l’utente di Network Load Balancer*.
**Esempio 4: come creare un gruppo di destinazione per indirizzare il traffico da un Network Load Balancer a un Application Load Balancer**
L’esempio `create-target-group` seguente crea un gruppo di destinazione per un Network Load Balancer in cui si registra un Application Load Balancer come destinazione (il tipo di destinazione è `alb`).
aws elbv2 create-target-group --name my-alb-target --protocol TCP --port 80 --target-type alb --vpc-id vpc-3ac0fb5f
Output:
```
{
"TargetGroups": [
{
"TargetGroupArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-alb-target/a3003e085dbb8ddc",
"TargetGroupName": "my-alb-target",
"Protocol": "TCP",
"Port": 80,
"VpcId": "vpc-838475fe",
"HealthCheckProtocol": "HTTP",
"HealthCheckPort": "traffic-port",
"HealthCheckEnabled": true,
"HealthCheckIntervalSeconds": 30,
"HealthCheckTimeoutSeconds": 6,
"HealthyThresholdCount": 5,
"UnhealthyThresholdCount": 2,
"HealthCheckPath": "/",
"Matcher": {
"HttpCode": "200-399"
},
"TargetType": "alb",
"IpAddressType": "ipv4"
}
]
}
```
Per ulteriori informazioni, consulta [Creazione del gruppo di destinazione con Application Load Balancer come destinazione](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/application-load-balancer-target.html) nella *Guida per l’utente di Network Load Balancer*.
**Esempio 5: come creare un gruppo di destinazione per un Gateway Load Balancer**
L’esempio `create-target-group` seguente crea un gruppo di destinazione per un Gateway Load Balancer in cui la destinazione è un’istanza e il protocollo del gruppo di destinazione è `GENEVE`.
```
aws elbv2 create-target-group \
--name my-glb-targetgroup \
--protocol GENEVE \
--port 6081 \
--target-type instance \
--vpc-id vpc-838475fe
```
Output:
```
{
"TargetGroups": [
{
"TargetGroupArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-glb-targetgroup/00c3d57eacd6f40b6f",
"TargetGroupName": "my-glb-targetgroup",
"Protocol": "GENEVE",
"Port": 6081,
"VpcId": "vpc-838475fe",
"HealthCheckProtocol": "TCP",
"HealthCheckPort": "80",
"HealthCheckEnabled": true,
"HealthCheckIntervalSeconds": 10,
"HealthCheckTimeoutSeconds": 5,
"HealthyThresholdCount": 5,
"UnhealthyThresholdCount": 2,
"TargetType": "instance"
}
]
}
```
*Per ulteriori informazioni, consulta Create a target group < https://docs.aws.amazon.com/elasticloadbalancing/ latest/gateway/create -target-group.html>`\$1\$1 nella Gateway Load Balancer User Guide.*
+ Per i [CreateTargetGroup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/create-target-group.html)dettagli *AWS CLI sull'*API, consulta Command Reference.
### `delete-listener`
Il seguente esempio di codice mostra come utilizzare`delete-listener`.
**AWS CLI**
**Come eliminare un listener**
L’esempio `delete-listener` seguente elimina il listener specificato.
```
aws elbv2 delete-listener \
--listener-arn arn:aws:elasticloadbalancing:ua-west-2:123456789012:listener/app/my-load-balancer/50dc6c495c0c9188/f2f7dc8efc522ab2
```
+ Per i dettagli sull'API, consulta [DeleteListener AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/delete-listener.html)*Command Reference*.
### `delete-load-balancer`
Il seguente esempio di codice mostra come utilizzare`delete-load-balancer`.
**AWS CLI**
**Come eliminare un bilanciatore del carico**
L’esempio `delete-load-balancer` seguente elimina il bilanciatore del carico specificato.
```
aws elbv2 delete-load-balancer \
--load-balancer-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-load-balancer/50dc6c495c0c9188
```
+ Per i dettagli sull'API, consulta [DeleteLoadBalancer AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/delete-load-balancer.html)*Command Reference*.
### `delete-rule`
Il seguente esempio di codice mostra come utilizzare`delete-rule`.
**AWS CLI**
**Come eliminare una regola**
L’esempio `delete-rule` seguente elimina la regola specificata.
```
aws elbv2 delete-rule \
--rule-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:listener-rule/app/my-load-balancer/50dc6c495c0c9188/f2f7dc8efc522ab2/1291d13826f405c3
```
+ Per i dettagli sull'API, consulta [DeleteRule AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/delete-rule.html)*Command Reference*.
### `delete-target-group`
Il seguente esempio di codice mostra come utilizzare`delete-target-group`.
**AWS CLI**
**Come eliminare un gruppo di destinazione**
L’esempio `delete-target-group` seguente elimina il gruppo di destinazione specificato.
```
aws elbv2 delete-target-group \
--target-group-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-targets/73e2d6bc24d8a067
```
Questo comando non produce alcun output.
Per ulteriori informazioni, consulta [Eliminare un bilanciatore del carico](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-delete.html) nella *Guida per l’utente di Application Load Balancer*.
+ Per i dettagli sull'API, consulta [DeleteTargetGroup AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/delete-target-group.html)*Command Reference*.
### `deregister-targets`
Il seguente esempio di codice mostra come utilizzare`deregister-targets`.
**AWS CLI**
**Esempio 1: come annullare la registrazione di una destinazione da un gruppo di destinazione**
L’esempio `deregister-targets` seguente rimuove l’istanza specificata dal gruppo di destinazione specificato.
```
aws elbv2 deregister-targets \
--target-group-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-targets/73e2d6bc24d8a067 \
--targets Id=i-1234567890abcdef0
```
**Esempio 2: come annullare la registrazione di una destinazione registrata utilizzando gli override delle porte**
L’esempio `deregister-targets` seguente rimuove un’istanza da un gruppo di destinazione registrato mediante gli override delle porte.
```
aws elbv2 deregister-targets \
--target-group-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-internal-targets/3bb63f11dfb0faf9 \
--targets Id=i-1234567890abcdef0,Port=80 Id=i-1234567890abcdef0,Port=766
```
+ Per i dettagli sull'API, consulta [DeregisterTargets AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/deregister-targets.html)*Command Reference*.
### `describe-account-limits`
Il seguente esempio di codice mostra come utilizzare`describe-account-limits`.
**AWS CLI**
**Come descrivere i limiti di Elastic Load Balancing**
L'`describe-account-limits`esempio seguente mostra i limiti di Elastic Load Balancing per il tuo AWS account nella regione corrente.
```
aws elbv2 describe-account-limits
```
Output:
```
{
"Limits": [
{
"Name": "target-groups",
"Max": "3000"
},
{
"Name": "targets-per-application-load-balancer",
"Max": "1000"
},
{
"Name": "listeners-per-application-load-balancer",
"Max": "50"
},
{
"Name": "rules-per-application-load-balancer",
"Max": "100"
},
{
"Name": "network-load-balancers",
"Max": "50"
},
{
"Name": "targets-per-network-load-balancer",
"Max": "3000"
},
{
"Name": "targets-per-availability-zone-per-network-load-balancer",
"Max": "500"
},
{
"Name": "listeners-per-network-load-balancer",
"Max": "50"
},
{
"Name": "condition-values-per-alb-rule",
"Max": "5"
},
{
"Name": "condition-wildcards-per-alb-rule",
"Max": "5"
},
{
"Name": "target-groups-per-application-load-balancer",
"Max": "100"
},
{
"Name": "target-groups-per-action-on-application-load-balancer",
"Max": "5"
},
{
"Name": "target-groups-per-action-on-network-load-balancer",
"Max": "1"
},
{
"Name": "certificates-per-application-load-balancer",
"Max": "25"
},
{
"Name": "certificates-per-network-load-balancer",
"Max": "25"
},
{
"Name": "targets-per-target-group",
"Max": "1000"
},
{
"Name": "target-id-registrations-per-application-load-balancer",
"Max": "1000"
},
{
"Name": "network-load-balancer-enis-per-vpc",
"Max": "1200"
},
{
"Name": "application-load-balancers",
"Max": "50"
},
{
"Name": "gateway-load-balancers",
"Max": "100"
},
{
"Name": "gateway-load-balancers-per-vpc",
"Max": "100"
},
{
"Name": "geneve-target-groups",
"Max": "100"
},
{
"Name": "targets-per-availability-zone-per-gateway-load-balancer",
"Max": "300"
}
]
}
```
Per ulteriori informazioni, consulta [Quotas](https://docs.aws.amazon.com/general/latest/gr/elb.html#limits_elastic_load_balancer) nella *documentazione generale di riferimento di AWS *.
+ Per i dettagli sull'API, consulta [DescribeAccountLimits AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/describe-account-limits.html)*Command Reference.*
### `describe-listener-certificates`
Il seguente esempio di codice mostra come utilizzare`describe-listener-certificates`.
**AWS CLI**
**Come descrivere i certificati per un listener sicuro**
Questo esempio descrive i certificati per il listener sicuro specificato.
Comando:
```
aws elbv2 describe-listener-certificates --listener-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:listener/app/my-load-balancer/50dc6c495c0c9188/f2f7dc8efc522ab2
```
Output:
```
{
"Certificates": [
{
"CertificateArn": "arn:aws:acm:us-west-2:123456789012:certificate/5cc54884-f4a3-4072-80be-05b9ba72f705",
"IsDefault": false
},
{
"CertificateArn": "arn:aws:acm:us-west-2:123456789012:certificate/3dcb0a41-bd72-4774-9ad9-756919c40557",
"IsDefault": false
},
{
"CertificateArn": "arn:aws:acm:us-west-2:123456789012:certificate/fe59da96-6f58-4a22-8eed-6d0d50477e1d",
"IsDefault": true
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeListenerCertificates AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/describe-listener-certificates.html)*Command Reference*.
### `describe-listeners`
Il seguente esempio di codice mostra come utilizzare`describe-listeners`.
**AWS CLI**
**Come descrivere un listener**
Questo esempio descrive il listener specificato.
Comando:
```
aws elbv2 describe-listeners --listener-arns arn:aws:elasticloadbalancing:us-west-2:123456789012:listener/app/my-load-balancer/50dc6c495c0c9188/f2f7dc8efc522ab2
```
Output:
```
{
"Listeners": [
{
"Port": 80,
"Protocol": "HTTP",
"DefaultActions": [
{
"TargetGroupArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-targets/73e2d6bc24d8a067",
"Type": "forward"
}
],
"LoadBalancerArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-load-balancer/50dc6c495c0c9188",
"ListenerArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:listener/app/my-load-balancer/50dc6c495c0c9188/f2f7dc8efc522ab2"
}
]
}
```
**Come descrivere i listener per un bilanciatore del carico**
Questo esempio descrive i listener per il bilanciatore del carico specificato.
Comando:
```
aws elbv2 describe-listeners --load-balancer-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-load-balancer/50dc6c495c0c9188
```
Output:
```
{
"Listeners": [
{
"Port": 443,
"Protocol": "HTTPS",
"DefaultActions": [
{
"TargetGroupArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-targets/73e2d6bc24d8a067",
"Type": "forward"
}
],
"SslPolicy": "ELBSecurityPolicy-2015-05",
"Certificates": [
{
"CertificateArn": "arn:aws:iam::123456789012:server-certificate/my-server-cert"
}
],
"LoadBalancerArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-load-balancer/50dc6c495c0c9188",
"ListenerArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:listener/app/my-load-balancer/50dc6c495c0c9188/0467ef3c8400ae65"
},
{
"Port": 80,
"Protocol": "HTTP",
"DefaultActions": [
{
"TargetGroupArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-targets/73e2d6bc24d8a067",
"Type": "forward"
}
],
"LoadBalancerArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-load-balancer/50dc6c495c0c9188",
"ListenerArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:listener/app/my-load-balancer/50dc6c495c0c9188/f2f7dc8efc522ab2"
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeListeners AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/describe-listeners.html)*Command Reference*.
### `describe-load-balancer-attributes`
Il seguente esempio di codice mostra come utilizzare`describe-load-balancer-attributes`.
**AWS CLI**
**Come descrivere gli attributi del bilanciatore del carico**
L’esempio `describe-load-balancer-attributes` seguente visualizza gli attributi del bilanciatore del carico specificato.
```
aws elbv2 describe-load-balancer-attributes \
--load-balancer-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-load-balancer/50dc6c495c0c9188
```
L’output dell’esempio seguente mostra gli attributi di un Application Load Balancer.
```
{
"Attributes": [
{
"Value": "false",
"Key": "access_logs.s3.enabled"
},
{
"Value": "",
"Key": "access_logs.s3.bucket"
},
{
"Value": "",
"Key": "access_logs.s3.prefix"
},
{
"Value": "60",
"Key": "idle_timeout.timeout_seconds"
},
{
"Value": "false",
"Key": "deletion_protection.enabled"
},
{
"Value": "true",
"Key": "routing.http2.enabled"
}
]
}
```
L’output dell’esempio seguente include gli attributi di un Network Load Balancer.
```
{
"Attributes": [
{
"Value": "false",
"Key": "access_logs.s3.enabled"
},
{
"Value": "",
"Key": "access_logs.s3.bucket"
},
{
"Value": "",
"Key": "access_logs.s3.prefix"
},
{
"Value": "false",
"Key": "deletion_protection.enabled"
},
{
"Value": "false",
"Key": "load_balancing.cross_zone.enabled"
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeLoadBalancerAttributes AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/describe-load-balancer-attributes.html)*Command Reference*.
### `describe-load-balancers`
Il seguente esempio di codice mostra come utilizzare`describe-load-balancers`.
**AWS CLI**
**Come descrivere un bilanciatore del carico**
Questo esempio descrive il bilanciatore del carico specificato.
Comando:
```
aws elbv2 describe-load-balancers --load-balancer-arns arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-load-balancer/50dc6c495c0c9188
```
Output:
```
{
"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": "2016-03-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": "active"
},
"LoadBalancerArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-load-balancer/50dc6c495c0c9188"
}
]
}
```
**Come descrivere tutti i bilanciatori del carico**
Questo esempio descrive tutti i bilanciatori del carico.
Comando:
```
aws elbv2 describe-load-balancers
```
+ Per i dettagli sull'API, consulta [DescribeLoadBalancers AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/describe-load-balancers.html)*Command Reference*.
### `describe-rules`
Il seguente esempio di codice mostra come utilizzare`describe-rules`.
**AWS CLI**
**Esempio 1: come descrivere una regola**
L’esempio `describe-rules` seguente visualizza i dettagli della regola specificata.
```
aws elbv2 describe-rules \
--rule-arns arn:aws:elasticloadbalancing:us-west-2:123456789012:listener-rule/app/my-load-balancer/50dc6c495c0c9188/f2f7dc8efc522ab2/9683b2d02a6cabee
```
**Esempio 2: come descrivere le regole per un listener**
L’esempio `describe-rules` seguente visualizza i dettagli delle regole per il listener specificato. L’output include la regola predefinita e tutte le altre regole aggiunte.
```
aws elbv2 describe-rules \
--listener-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:listener/app/my-load-balancer/50dc6c495c0c9188/f2f7dc8efc522ab2
```
+ Per i dettagli sull'API, consulta [DescribeRules AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/describe-rules.html)*Command Reference*.
### `describe-ssl-policies`
Il seguente esempio di codice mostra come utilizzare`describe-ssl-policies`.
**AWS CLI**
**Esempio 1: come elencare le policy utilizzate per la negoziazione SSL in base al tipo di bilanciatore del carico**
L’esempio `describe-ssl-policies` seguente visualizza i nomi delle policy che è possibile utilizzare per la negoziazione SSL con un Application Load Balancer. L’esempio utilizza il parametro `--query` per visualizzare solo i nomi delle policy.
```
aws elbv2 describe-ssl-policies \
--load-balancer-type application \
--query SslPolicies[*].Name
```
Output:
```
[
"ELBSecurityPolicy-2016-08",
"ELBSecurityPolicy-TLS13-1-2-2021-06",
"ELBSecurityPolicy-TLS13-1-2-Res-2021-06",
"ELBSecurityPolicy-TLS13-1-2-Ext1-2021-06",
"ELBSecurityPolicy-TLS13-1-2-Ext2-2021-06",
"ELBSecurityPolicy-TLS13-1-1-2021-06",
"ELBSecurityPolicy-TLS13-1-0-2021-06",
"ELBSecurityPolicy-TLS13-1-3-2021-06",
"ELBSecurityPolicy-TLS-1-2-2017-01",
"ELBSecurityPolicy-TLS-1-1-2017-01",
"ELBSecurityPolicy-TLS-1-2-Ext-2018-06",
"ELBSecurityPolicy-FS-2018-06",
"ELBSecurityPolicy-2015-05",
"ELBSecurityPolicy-TLS-1-0-2015-04",
"ELBSecurityPolicy-FS-1-2-Res-2019-08",
"ELBSecurityPolicy-FS-1-1-2019-08",
"ELBSecurityPolicy-FS-1-2-2019-08",
"ELBSecurityPolicy-FS-1-2-Res-2020-10"
]
```
**Esempio 2: come elencare le policy che supportano un protocollo specifico**
L’esempio `describe-ssl-policies` seguente visualizza i nomi delle policy che supportano il protocollo TLS 1.3. L’esempio utilizza il parametro `--query` per visualizzare solo i nomi delle policy.
```
aws elbv2 describe-ssl-policies \
--load-balancer-type application \
--query SslPolicies[?contains(SslProtocols,'TLSv1.3')].Name
```
Output:
```
[
"ELBSecurityPolicy-TLS13-1-2-2021-06",
"ELBSecurityPolicy-TLS13-1-2-Res-2021-06",
"ELBSecurityPolicy-TLS13-1-2-Ext1-2021-06",
"ELBSecurityPolicy-TLS13-1-2-Ext2-2021-06",
"ELBSecurityPolicy-TLS13-1-1-2021-06",
"ELBSecurityPolicy-TLS13-1-0-2021-06",
"ELBSecurityPolicy-TLS13-1-3-2021-06"
]
```
**Esempio 3: come visualizzare i tipi di crittografia di una policy**
L’esempio `describe-ssl-policies` seguente visualizza i nomi delle crittografie per la policy specificata. L’esempio utilizza il parametro `--query` per visualizzare solo i nomi delle crittografie. La prima crittografia dell’elenco ha priorità 1 e le crittografie rimanenti sono in ordine di priorità.
```
aws elbv2 describe-ssl-policies \
--names ELBSecurityPolicy-TLS13-1-2-2021-06 \
--query SslPolicies[*].Ciphers[*].Name
```
Output:
```
[
"TLS_AES_128_GCM_SHA256",
"TLS_AES_256_GCM_SHA384",
"TLS_CHACHA20_POLY1305_SHA256",
"ECDHE-ECDSA-AES128-GCM-SHA256",
"ECDHE-RSA-AES128-GCM-SHA256",
"ECDHE-ECDSA-AES128-SHA256",
"ECDHE-RSA-AES128-SHA256",
"ECDHE-ECDSA-AES256-GCM-SHA384",
"ECDHE-RSA-AES256-GCM-SHA384",
"ECDHE-ECDSA-AES256-SHA384",
"ECDHE-RSA-AES256-SHA384"
]
```
Per ulteriori informazioni, consulta [Policy di sicurezza](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/create-https-listener.html#describe-ssl-policies) nella *Guida per l’utente di Application Load Balancer*.
+ Per i dettagli sull'API, consulta [DescribeSslPolicies AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/describe-ssl-policies.html)*Command Reference*.
### `describe-tags`
Il seguente esempio di codice mostra come utilizzare`describe-tags`.
**AWS CLI**
**Come descrivere i tag assegnati a un bilanciatore del carico**
Questo esempio descrive i tag assegnati al bilanciatore del carico specificato.
Comando:
```
aws elbv2 describe-tags --resource-arns arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-load-balancer/50dc6c495c0c9188
```
Output:
```
{
"TagDescriptions": [
{
"ResourceArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-load-balancer/50dc6c495c0c9188",
"Tags": [
{
"Value": "lima",
"Key": "project"
},
{
"Value": "digital-media",
"Key": "department"
}
]
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeTags AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/describe-tags.html)*Command Reference*.
### `describe-target-group-attributes`
Il seguente esempio di codice mostra come utilizzare`describe-target-group-attributes`.
**AWS CLI**
**Come descrivere gli attributi del gruppo di destinazione**
L’esempio `describe-target-group-attributes` seguente visualizza gli attributi del gruppo di destinazione specificato.
```
aws elbv2 describe-target-group-attributes \
--target-group-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-targets/73e2d6bc24d8a067
```
L’output include gli attributi se il protocollo è HTTP o HTTPS e il tipo di destinazione è `instance` o `ip`.
```
{
"Attributes": [
{
"Value": "false",
"Key": "stickiness.enabled"
},
{
"Value": "300",
"Key": "deregistration_delay.timeout_seconds"
},
{
"Value": "lb_cookie",
"Key": "stickiness.type"
},
{
"Value": "86400",
"Key": "stickiness.lb_cookie.duration_seconds"
},
{
"Value": "0",
"Key": "slow_start.duration_seconds"
}
]
}
```
Il seguente output include gli attributi se il protocollo è HTTP o HTTPS e il tipo di destinazione è `lambda`.
```
{
"Attributes": [
{
"Value": "false",
"Key": "lambda.multi_value_headers.enabled"
}
]
}
```
Il seguente output include gli attributi se il protocollo è TCP, TLS, UDP o TCP\$1UDP.
```
{
"Attributes": [
{
"Value": "false",
"Key": "proxy_protocol_v2.enabled"
},
{
"Value": "300",
"Key": "deregistration_delay.timeout_seconds"
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeTargetGroupAttributes AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/describe-target-group-attributes.html)*Command Reference*.
### `describe-target-groups`
Il seguente esempio di codice mostra come utilizzare`describe-target-groups`.
**AWS CLI**
**Esempio 1: come descrivere un gruppo di destinazione**
L’esempio `describe-target-groups` seguente visualizza i dettagli del gruppo di destinazione specificato.
```
aws elbv2 describe-target-groups \
--target-group-arns arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-targets/73e2d6bc24d8a067
```
Output:
```
{
"TargetGroups": [
{
"TargetGroupArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-targets/73e2d6bc24d8a067",
"TargetGroupName": "my-targets",
"Protocol": "HTTP",
"Port": 80,
"VpcId": "vpc-3ac0fb5f",
"HealthCheckProtocol": "HTTP",
"HealthCheckPort": "traffic-port",
"HealthCheckEnabled": true,
"HealthCheckIntervalSeconds": 30,
"HealthCheckTimeoutSeconds": 5,
"HealthyThresholdCount": 5,
"UnhealthyThresholdCount": 2,
"HealthCheckPath": "/",
"Matcher": {
"HttpCode": "200"
},
"LoadBalancerArns": [
"arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-load-balancer/50dc6c495c0c9188"
],
"TargetType": "instance",
"ProtocolVersion": "HTTP1",
"IpAddressType": "ipv4"
}
]
}
```
**Esempio 2: come descrivere tutti i gruppi di destinazione per un bilanciatore del carico**
L’esempio `describe-target-groups` seguente visualizza i dettagli di tutti i gruppi di destinazione per il bilanciatore del carico specificato. L’esempio utilizza il parametro `--query` per visualizzare solo i nomi dei gruppi di destinazione.
```
aws elbv2 describe-target-groups \
--load-balancer-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-load-balancer/50dc6c495c0c9188 \
--query TargetGroups[*].TargetGroupName
```
Output:
```
[
"my-instance-targets",
"my-ip-targets",
"my-lambda-target"
]
```
Per ulteriori informazioni, consulta [Target groups](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-target-groups.html) nella *Application Load Balancers Guide.*
+ Per i dettagli sull'API, consulta *AWS CLI Command [DescribeTargetGroups](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/describe-target-groups.html)Reference*.
### `describe-target-health`
Il seguente esempio di codice mostra come utilizzare`describe-target-health`.
**AWS CLI**
**Esempio 1: come descrivere l’integrità delle destinazioni per un gruppo di destinazione**
L’esempio `describe-target-health` seguente visualizza i dettagli dell’integrità delle destinazioni del gruppo di destinazione specificato. Queste destinazioni sono integre.
```
aws elbv2 describe-target-health \
--target-group-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-targets/73e2d6bc24d8a067
```
Output:
```
{
"TargetHealthDescriptions": [
{
"HealthCheckPort": "80",
"Target": {
"Id": "i-ceddcd4d",
"Port": 80
},
"TargetHealth": {
"State": "healthy"
}
},
{
"HealthCheckPort": "80",
"Target": {
"Id": "i-0f76fade",
"Port": 80
},
"TargetHealth": {
"State": "healthy"
}
}
]
}
```
**Esempio 2: come descrivere l’integrità di una destinazione**
L’esempio `describe-target-health` seguente visualizza i dettagli relativi all’integrità della destinazione specificata. La destinazione è integra.
```
aws elbv2 describe-target-health \
--targets Id=i-0f76fade,Port=80 \
--target-group-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-targets/73e2d6bc24d8a067
```
Output:
```
{
"TargetHealthDescriptions": [
{
"HealthCheckPort": "80",
"Target": {
"Id": "i-0f76fade",
"Port": 80
},
"TargetHealth": {
"State": "healthy"
}
}
]
}
```
L’output di esempio seguente si riferisce a una destinazione il cui gruppo di destinazione non è specificato in un’azione per un listener. Questa destinazione non può ricevere traffico dal bilanciatore del carico.
```
{
"TargetHealthDescriptions": [
{
"HealthCheckPort": "80",
"Target": {
"Id": "i-0f76fade",
"Port": 80
},
"TargetHealth": {
"State": "unused",
"Reason": "Target.NotInUse",
"Description": "Target group is not configured to receive traffic from the load balancer"
}
}
]
}
```
L’output di esempio seguente si riferisce a una destinazione il cui gruppo di destinazione è stato specificato in un’azione per un listener. La destinazione è ancora in fase di registrazione.
```
{
"TargetHealthDescriptions": [
{
"HealthCheckPort": "80",
"Target": {
"Id": "i-0f76fade",
"Port": 80
},
"TargetHealth": {
"State": "initial",
"Reason": "Elb.RegistrationInProgress",
"Description": "Target registration is in progress"
}
}
]
}
```
Il seguente output di esempio fa riferimento a una destinazione integra.
```
{
"TargetHealthDescriptions": [
{
"HealthCheckPort": "80",
"Target": {
"Id": "i-0f76fade",
"Port": 80
},
"TargetHealth": {
"State": "unhealthy",
"Reason": "Target.Timeout",
"Description": "Connection to target timed out"
}
}
]
}
```
L’output di esempio seguente si riferisce a una destinazione che è una funzione Lambda e i controlli dell’integrità sono disabilitati.
```
{
"TargetHealthDescriptions": [
{
"Target": {
"Id": "arn:aws:lambda:us-west-2:123456789012:function:my-function",
"AvailabilityZone": "all",
},
"TargetHealth": {
"State": "unavailable",
"Reason": "Target.HealthCheckDisabled",
"Description": "Health checks are not enabled for this target"
}
}
]
}
```
+ Per i dettagli sull'API, consulta [DescribeTargetHealth AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/describe-target-health.html)*Command Reference*.
### `modify-listener`
Il seguente esempio di codice mostra come utilizzare`modify-listener`.
**AWS CLI**
**Esempio 1: come modificare l’azione predefinita in un’azione di inoltro**
L’esempio `modify-listener` seguente modifica l’azione predefinita impostandola su un’azione `forward` per il listener specificato.
```
aws elbv2 modify-listener \
--listener-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:listener/app/my-load-balancer/50dc6c495c0c9188/f2f7dc8efc522ab2 \
--default-actions Type=forward,TargetGroupArn=arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-new-targets/2453ed029918f21f
```
Output:
```
{
"Listeners": [
{
"ListenerArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:listener/app/my-load-balancer/50dc6c495c0c9188/f2f7dc8efc522ab2",
"LoadBalancerArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-load-balancer/50dc6c495c0c9188",
"Protocol": "HTTP",
"Port": 80,
"DefaultActions": [
{
"Type": "forward",
"TargetGroupArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-new-targets/2453ed029918f21f"
}
]
}
]
}
```
**Esempio 2: come modificare l’azione predefinita in un’azione di reindirizzamento**
L’esempio `modify-listener` seguente modifica l’azione predefinita impostandola su un’azione `redirect` per il listener specificato.
```
aws elbv2 modify-listener \
--listener-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:listener/app/my-load-balancer/50dc6c495c0c9188/f2f7dc8efc522ab2 \
--default-actions Type=redirect, RedirectConfig='{Protocol=HTTPS,StatusCode=HTTP_302}'
```
Output:
```
{
"Listeners": [
{
"ListenerArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:listener/app/my-load-balancer/50dc6c495c0c9188/f2f7dc8efc522ab2",
"LoadBalancerArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-load-balancer/50dc6c495c0c9188",
"Protocol": "HTTP",
"Port": 80,
"DefaultActions": [
{
"Type": "redirect",
"RedirectConfig": {
"Protocol": "HTTPS",
"Port": "#{port}",
"Host": "#{host}",
"Path": "/#{path}",
"Query": "#{query}",
"StatusCode": "HTTP_302",
}
}
]
}
]
}
```
**Esempio 3: come modificare il certificato del server**
L’esempio `modify-listener` seguente modifica il certificato del server per il listener HTTPS specificato.
```
aws elbv2 modify-listener \
--listener-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:listener/app/my-load-balancer/50dc6c495c0c9188/0467ef3c8400ae65 \
--certificates CertificateArn=arn:aws:iam::123456789012:server-certificate/my-new-server-cert
```
Output:
```
{
"Listeners": [
{
"ListenerArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:listener/app/my-load-balancer/50dc6c495c0c9188/0467ef3c8400ae65",
"LoadBalancerArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-load-balancer/50dc6c495c0c9188",
"Protocol": "HTTPS",
"Port": 443,
"DefaultActions": [
{
"Type": "forward",
"TargetGroupArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-targets/73e2d6bc24d8a067"
}
],
"SslPolicy": "ELBSecurityPolicy-2015-05",
"Certificates": [
{
"CertificateArn": "arn:aws:iam::123456789012:server-certificate/my-new-server-cert"
}
],
}
]
}
```
Per ulteriori informazioni, consulta [Regole dei listener](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-listeners.html#listener-rules) nella *Guida per l’utente di Application Load Balancer*.
+ Per i dettagli sull'API, consulta [ModifyListener AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/modify-listener.html)*Command Reference*.
### `modify-load-balancer-attributes`
Il seguente esempio di codice mostra come utilizzare`modify-load-balancer-attributes`.
**AWS CLI**
**Come abilitare la protezione dall’eliminazione**
Questo esempio abilita la protezione dall’eliminazione per il bilanciatore del carico specificato.
Comando:
```
aws elbv2 modify-load-balancer-attributes --load-balancer-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-load-balancer/50dc6c495c0c9188 --attributes Key=deletion_protection.enabled,Value=true
```
Output:
```
{
"Attributes": [
{
"Value": "true",
"Key": "deletion_protection.enabled"
},
{
"Value": "false",
"Key": "access_logs.s3.enabled"
},
{
"Value": "60",
"Key": "idle_timeout.timeout_seconds"
},
{
"Value": "",
"Key": "access_logs.s3.prefix"
},
{
"Value": "",
"Key": "access_logs.s3.bucket"
}
]
}
```
**Come modificare il timeout di inattività**
Questo esempio modifica il valore del timeout di inattività per il bilanciatore del carico specificato.
Comando:
```
aws elbv2 modify-load-balancer-attributes --load-balancer-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-load-balancer/50dc6c495c0c9188 --attributes Key=idle_timeout.timeout_seconds,Value=30
```
Output:
```
{
"Attributes": [
{
"Value": "30",
"Key": "idle_timeout.timeout_seconds"
},
{
"Value": "false",
"Key": "access_logs.s3.enabled"
},
{
"Value": "",
"Key": "access_logs.s3.prefix"
},
{
"Value": "true",
"Key": "deletion_protection.enabled"
},
{
"Value": "",
"Key": "access_logs.s3.bucket"
}
]
}
```
**Come abilitare il log degli accessi**
Questo esempio abilita il log degli accessi per il bilanciatore del carico specificato. Nota che il bucket S3 deve esistere nella stessa Regione del bilanciatore del carico e deve includere una policy associata che conceda l’accesso al servizio Elastic Load Balancing.
Comando:
```
aws elbv2 modify-load-balancer-attributes --load-balancer-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-load-balancer/50dc6c495c0c9188 --attributes Key=access_logs.s3.enabled,Value=true Key=access_logs.s3.bucket,Value=my-loadbalancer-logs Key=access_logs.s3.prefix,Value=myapp
```
Output:
```
{
"Attributes": [
{
"Value": "true",
"Key": "access_logs.s3.enabled"
},
{
"Value": "my-load-balancer-logs",
"Key": "access_logs.s3.bucket"
},
{
"Value": "myapp",
"Key": "access_logs.s3.prefix"
},
{
"Value": "60",
"Key": "idle_timeout.timeout_seconds"
},
{
"Value": "false",
"Key": "deletion_protection.enabled"
}
]
}
```
+ Per i dettagli sull'API, consulta [ModifyLoadBalancerAttributes AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/modify-load-balancer-attributes.html)*Command Reference*.
### `modify-rule`
Il seguente esempio di codice mostra come utilizzare`modify-rule`.
**AWS CLI**
**Come modificare una regola**
L’esempio `modify-rule` seguente aggiorna le azioni e le condizioni per la regola specificata.
```
aws elbv2 modify-rule \
--actions Type=forward,TargetGroupArn=arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-targets/73e2d6bc24d8a067 \
--conditions Field=path-pattern,Values='/images/*'
--rule-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:listener-rule/app/my-load-balancer/50dc6c495c0c9188/f2f7dc8efc522ab2/9683b2d02a6cabee
```
Output:
```
{
"Rules": [
{
"Priority": "10",
"Conditions": [
{
"Field": "path-pattern",
"Values": [
"/images/*"
]
}
],
"RuleArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:listener-rule/app/my-load-balancer/50dc6c495c0c9188/f2f7dc8efc522ab2/9683b2d02a6cabee",
"IsDefault": false,
"Actions": [
{
"TargetGroupArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-targets/73e2d6bc24d8a067",
"Type": "forward"
}
]
}
]
}
```
+ Per i dettagli sull'API, consulta [ModifyRule AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/modify-rule.html)*Command Reference*.
### `modify-target-group-attributes`
Il seguente esempio di codice mostra come utilizzare`modify-target-group-attributes`.
**AWS CLI**
**Come modificare il timeout del ritardo di annullamento della registrazione**
Questo esempio imposta il timeout del ritardo dell’annullamento della registrazione sul valore specificato per il gruppo di destinazione specificato.
Comando:
```
aws elbv2 modify-target-group-attributes --target-group-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-targets/73e2d6bc24d8a067 --attributes Key=deregistration_delay.timeout_seconds,Value=600
```
Output:
```
{
"Attributes": [
{
"Value": "false",
"Key": "stickiness.enabled"
},
{
"Value": "600",
"Key": "deregistration_delay.timeout_seconds"
},
{
"Value": "lb_cookie",
"Key": "stickiness.type"
},
{
"Value": "86400",
"Key": "stickiness.lb_cookie.duration_seconds"
}
]
}
```
+ Per i dettagli sull'API, consulta [ModifyTargetGroupAttributes AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/modify-target-group-attributes.html)*Command Reference*.
### `modify-target-group`
Il seguente esempio di codice mostra come utilizzare`modify-target-group`.
**AWS CLI**
**Come modificare le impostazioni di controllo dell’integrità per un gruppo di destinazione**
L’esempio `modify-target-group` seguente modifica la configurazione dei controlli dell’integrità utilizzati per valutare lo stato delle destinazioni per il gruppo di destinazione specificato. A causa del modo in cui la CLI analizza le virgole, è necessario racchiudere l’intervallo dell’opzione `--matcher` tra virgolette singole anziché virgolette doppie.
```
aws elbv2 modify-target-group \
--target-group-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-https-targets/2453ed029918f21f \
--health-check-protocol HTTPS \
--health-check-port 443 \
--matcher HttpCode='200,299'
```
Output:
```
{
"TargetGroups": [
{
"TargetGroupArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-https-targets/2453ed029918f21f",
"TargetGroupName": "my-https-targets",
"Protocol": "HTTPS",
"Port": 443,
"VpcId": "vpc-3ac0fb5f",
"HealthCheckProtocol": "HTTPS",
"HealthCheckPort": "443",
"HealthCheckEnabled": true,
"HealthCheckIntervalSeconds": 30,
"HealthCheckTimeoutSeconds": 5,
"HealthyThresholdCount": 5,
"UnhealthyThresholdCount": 2,
"Matcher": {
"HttpCode": "200,299"
},
"LoadBalancerArns": [
"arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-load-balancer/50dc6c495c0c9188"
],
"TargetType": "instance",
"ProtocolVersion": "HTTP1",
"IpAddressType": "ipv4"
}
]
}
```
Per ulteriori informazioni, consulta [Target groups](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-target-groups.html) nella *Application Load Balancers Guide.*
+ Per i dettagli sull'API, consulta *AWS CLI Command [ModifyTargetGroup](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/modify-target-group.html)Reference*.
### `register-targets`
Il seguente esempio di codice mostra come utilizzare`register-targets`.
**AWS CLI**
**Esempio 1: come registrare le destinazioni con un gruppo di destinazione in base all’ID dell’istanza**
L’esempio `register-targets` seguente registra le istanze specificate con un gruppo di destinazione. Il tipo di destinazione del gruppo di destinazione deve essere `instance`.
```
aws elbv2 register-targets \
--target-group-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-targets/73e2d6bc24d8a067 \
--targets Id=i-1234567890abcdef0 Id=i-0abcdef1234567890
```
**Esempio 2: come registrare le destinazioni con un gruppo di destinazione utilizzando gli override delle porte**
L’esempio `register-targets` seguente registra l’istanza specificata con un gruppo di destinazione utilizzando più porte. Ciò consente di registrare i container sulla stessa istanza delle destinazioni nel gruppo di destinazione.
```
aws elbv2 register-targets \
--target-group-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-internal-targets/3bb63f11dfb0faf9 \
--targets Id=i-0598c7d356eba48d7,Port=80 Id=i-0598c7d356eba48d7,Port=766
```
**Esempio 3: come registrare le destinazioni con un gruppo di destinazione in base all’indirizzo IP**
L’esempio `register-targets` seguente registra gli indirizzi IP specificati con un gruppo di destinazione. Il tipo di destinazione del gruppo di destinazione deve essere `ip`.
```
aws elbv2 register-targets \
--target-group-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-tcp-ip-targets/8518e899d173178f \
--targets Id=10.0.1.15 Id=10.0.1.23
```
**Esempio 4: come registrare una funzione Lambda come destinazione**
L’esempio `register-targets` seguente registra gli indirizzi IP specificati con un gruppo di destinazione. Il tipo di destinazione del gruppo di destinazione deve essere `lambda`. Per invocare la funzione Lambda, devi concedere l’autorizzazione Elastic Load Balancing.
```
aws elbv2 register-targets \
--target-group-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-tcp-ip-targets/8518e899d173178f \
--targets Id=arn:aws:lambda:us-west-2:123456789012:function:my-function
```
+ Per i dettagli sull'API, consulta [RegisterTargets AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/register-targets.html)*Command Reference*.
### `remove-listener-certificates`
Il seguente esempio di codice mostra come utilizzare`remove-listener-certificates`.
**AWS CLI**
**Come rimuovere un certificato da un listener sicuro**
Questo esempio rimuove il certificato specificato dal listener sicuro specificato.
Comando:
```
aws elbv2 remove-listener-certificates --listener-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:listener/app/my-load-balancer/50dc6c495c0c9188/f2f7dc8efc522ab2 --certificates CertificateArn=arn:aws:acm:us-west-2:123456789012:certificate/5cc54884-f4a3-4072-80be-05b9ba72f705
```
+ Per i dettagli sull'API, consulta [RemoveListenerCertificates AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/remove-listener-certificates.html)*Command Reference*.
### `remove-tags`
Il seguente esempio di codice mostra come utilizzare`remove-tags`.
**AWS CLI**
**Come rimuovere i tag da un bilanciatore del carico**
L’esempio `remove-tags` seguente rimuove i tag `project` e `department` dal bilanciatore del carico specificato.
```
aws elbv2 remove-tags \
--resource-arns arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-load-balancer/50dc6c495c0c9188 \
--tag-keys project department
```
+ Per i dettagli sull'API, consulta [RemoveTags AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/remove-tags.html)*Command Reference*.
### `set-ip-address-type`
Il seguente esempio di codice mostra come utilizzare`set-ip-address-type`.
**AWS CLI**
**Come impostare il tipo di indirizzo di un bilanciatore del carico**
Questo esempio imposta il tipo di indirizzo del bilanciatore del carico specificato su `dualstack`. Le sottoreti di bilanciamento del carico devono avere blocchi CIDR associati IPv6 .
Comando:
```
aws elbv2 set-ip-address-type --load-balancer-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-load-balancer/50dc6c495c0c9188 --ip-address-type dualstack
```
Output:
```
{
"IpAddressType": "dualstack"
}
```
+ *Per i dettagli sull'API, vedere [SetIpAddressType](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/set-ip-address-type.html)in Command Reference.AWS CLI *
### `set-rule-priorities`
Il seguente esempio di codice mostra come utilizzare`set-rule-priorities`.
**AWS CLI**
**Come impostare la priorità della regola**
Questo esempio imposta la priorità della regola specificata.
Comando:
```
aws elbv2 set-rule-priorities --rule-priorities RuleArn=arn:aws:elasticloadbalancing:us-west-2:123456789012:listener-rule/app/my-load-balancer/50dc6c495c0c9188/f2f7dc8efc522ab2/1291d13826f405c3,Priority=5
```
Output:
```
{
"Rules": [
{
"Priority": "5",
"Conditions": [
{
"Field": "path-pattern",
"Values": [
"/img/*"
]
}
],
"RuleArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:listener-rule/app/my-load-balancer/50dc6c495c0c9188/f2f7dc8efc522ab2/1291d13826f405c3",
"IsDefault": false,
"Actions": [
{
"TargetGroupArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-targets/73e2d6bc24d8a067",
"Type": "forward"
}
]
}
]
}
```
+ Per i dettagli sull'API, consulta [SetRulePriorities AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/set-rule-priorities.html)*Command Reference*.
### `set-security-groups`
Il seguente esempio di codice mostra come utilizzare`set-security-groups`.
**AWS CLI**
**Come associare un gruppo di sicurezza a un bilanciatore del carico**
Questo esempio associa il gruppo di sicurezza specificato al bilanciatore del carico specificato.
Comando:
```
aws elbv2 set-security-groups --load-balancer-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-load-balancer/50dc6c495c0c9188 --security-groups sg-5943793c
```
Output:
```
{
"SecurityGroupIds": [
"sg-5943793c"
]
}
```
+ Per i dettagli sull'API, consulta [SetSecurityGroups AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/set-security-groups.html)*Command Reference*.
### `set-subnets`
Il seguente esempio di codice mostra come utilizzare`set-subnets`.
**AWS CLI**
**Come abilitare le zone di disponibilità per un bilanciatore del carico**
Questo esempio abilita la zona di disponibilità per la sottorete specificata per il bilanciatore del carico specificato.
Comando:
```
aws elbv2 set-subnets --load-balancer-arn arn:aws:elasticloadbalancing:us-west-2:123456789012:loadbalancer/app/my-load-balancer/50dc6c495c0c9188 --subnets subnet-8360a9e7 subnet-b7d581c0
```
Output:
```
{
"AvailabilityZones": [
{
"SubnetId": "subnet-8360a9e7",
"ZoneName": "us-west-2a"
},
{
"SubnetId": "subnet-b7d581c0",
"ZoneName": "us-west-2b"
}
]
}
```
+ Per i dettagli sull'API, consulta [SetSubnets AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/elbv2/set-subnets.html)*Command Reference*.