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à.
# Regole dell'ascoltatore per Application Load Balancer
Le regole del listener per l'Application Load Balancer determinano il modo in cui instrada le richieste verso le destinazioni. Quando un listener riceve una richiesta, la valuta in base a ciascuna regola in ordine di priorità, a partire dalla regola con il numero più basso. Ogni regola include le condizioni da soddisfare e le azioni da eseguire quando vengono soddisfatte le condizioni della regola. Questo meccanismo di routing flessibile consente di implementare sofisticati modelli di distribuzione del traffico, supportare più applicazioni o microservizi con un unico sistema di bilanciamento del carico e personalizzare la gestione delle richieste in base ai requisiti specifici dell'applicazione.
**Nozioni di base sulle regole**
+ Ogni regola è composta dai seguenti componenti: priorità, azioni, condizioni e trasformazioni opzionali.
+ Ogni azione della regola ha un tipo e le informazioni necessarie per eseguire l'azione.
+ Ogni condizione della regola ha un tipo e le informazioni necessarie per valutare la condizione.
+ Ogni trasformazione di regola ha un'espressione regolare a cui corrispondere e una stringa sostitutiva.
+ Le operazioni per la regola predefinita vengono definite al momento della creazione del listener. La regola predefinita non può avere condizioni o trasformazioni. Se non viene soddisfatta nessuna delle condizioni per le altre regole, viene eseguita l'azione per la regola predefinita.
+ Le regole vengono valutate in base all’ordine di priorità, dal valore più basso a quello più alto. La regola predefinita è valutata per ultima. Non è possibile modificare la priorità della regola predefinita.
+ Ogni regola deve includere esattamente una delle seguenti operazioni: `forward`, `redirect` o `fixed-response` e deve essere l’ultima operazione da eseguire.
+ Ogni regola diversa da quella predefinita può includere facoltativamente una delle seguenti condizioni:`host-header`, `http-request-method``path-pattern`, e`source-ip`. Facoltativamente può anche includere una o entrambe le seguenti condizioni: `http-header` e. `query-string`
+ Ogni regola diversa dalla regola predefinita può includere facoltativamente una trasformazione di riscrittura dell'intestazione dell'host e una trasformazione di riscrittura dell'URL.
+ Puoi specificare fino a tre stringhe di confronto per condizione e fino a cinque per regola.
**Topics**
+ [Tipi di operazione](rule-action-types.md)
+ [Tipi di condizioni](rule-condition-types.md)
+ [Trasformazioni](rule-transforms.md)
+ [Aggiungere una regola](add-rule.md)
+ [Modificare una regola](edit-rule.md)
+ [Eliminare una regola](delete-rule.md)
# Tipi di azione per le regole del listener
Le azioni determinano il modo in cui un sistema di bilanciamento del carico gestisce le richieste quando le condizioni per una regola del listener sono soddisfatte. Ogni regola deve avere almeno un'azione che specifichi come gestire le richieste corrispondenti. Ogni azione della regola ha un tipo e informazioni di configurazione. Gli Application Load Balancer supportano i seguenti tipi di azioni per le regole del listener.Tipi di operazione
`authenticate-cognito`
[Ascoltatori HTTPS] Utilizzare Amazon Cognito per autenticare gli utenti. Per ulteriori informazioni, consulta [Autenticazione dell'utente](listener-authenticate-users.md).
`authenticate-oidc`
[Listener HTTPS] Utilizzare un provider di identità compatibile con OpenID Connect (OIDC) per autenticare gli utenti. Per ulteriori informazioni, consulta [Autenticazione dell'utente](listener-authenticate-users.md).
`fixed-response`
Restituire una risposta HTTP personalizzata. Per ulteriori informazioni, consulta [Operazioni con risposta fissa](#fixed-response-actions).
`forward`
Inoltrare le richieste verso il gruppo di destinazioni indicato. Per ulteriori informazioni, consulta [Operazioni di inoltro](#forward-actions).
`jwt-validation`
Convalida i token di accesso JWT nelle richieste dei client. Per ulteriori informazioni, consulta [Verifica JWT](listener-verify-jwt.md).
`redirect`
Reindirizzare le richieste da un URL a un altro. Per ulteriori informazioni, consulta [Operazioni di reindirizzamento](#redirect-actions).
**Nozioni di base sull'azione**
+ Ogni regola deve includere esattamente una delle seguenti azioni di routing: `forward``redirect`,`fixed-response`, o e deve essere l'ultima azione da eseguire.
+ Un listener HTTPS può avere una regola con un'azione di autenticazione utente e un'azione di routing.
+ Quando sono presenti più azioni, l'azione con la priorità più bassa viene eseguita per prima.
+ Se la versione del protocollo è gRPC o HTTP/2, le uniche operazioni supportate sono le operazioni `forward`.
## Operazioni con risposta fissa
Un'`fixed-response`azione elimina le richieste del client e restituisce una risposta HTTP personalizzata. È possibile utilizzare questa operazione per inviare un codice di risposta 2XX, 4XX o 5XX e un messaggio opzionale.
Quando viene eseguita un'operazione `fixed-response`, l'operazione e l'URL del target di reindirizzamento vengono registrate nei log di accesso. Per ulteriori informazioni, consulta [Voci dei log di accesso](load-balancer-access-logs.md#access-log-entry-format). Il conteggio delle operazioni `fixed-response` avvenute con successo viene segnalato dal parametro `HTTP_Fixed_Response_Count`. Per ulteriori informazioni, consulta [Parametri di Application Load Balancer](load-balancer-cloudwatch-metrics.md#load-balancer-metrics-alb).
**Example Esempio di azione a risposta fissa**
Puoi specificare un’operazione quando crei o modifichi una regola. Per ulteriori informazioni consulta i comandi [create-rule](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-rule.html) e [modify-rule](https://docs.aws.amazon.com/cli/latest/reference/elbv2/modify-rule.html). Le seguenti operazioni inviano una risposta fissa con il codice di stato specificato e il corpo del messaggio.
```
[
{
"Type": "fixed-response",
"FixedResponseConfig": {
"StatusCode": "200",
"ContentType": "text/plain",
"MessageBody": "Hello world"
}
}
]
```
## Operazioni di inoltro
Un'operazione `forward` instrada le richieste verso il gruppo target. Prima di aggiungere un’operazione `forward`, crea il gruppo target e aggiungi i target. Per ulteriori informazioni, consulta [Creazione di un gruppo target](create-target-group.md).
**Distribuisci il traffico a più gruppi target**
Se si specificano più gruppi di destinazioni per un'operazione `forward`, è necessario specificare un peso per ciascun gruppo di destinazioni. Ogni peso del gruppo di destinazioni è un valore compreso tra 0 e 999. Le richieste che corrispondono a una regola del listener con gruppi di destinazioni ponderati vengono distribuite a questi gruppi di destinazioni in base ai rispettivi pesi. Ad esempio, se specifichi due gruppi di destinazioni, ciascuno con un peso di 10, ogni gruppo di destinazioni riceve la metà delle richieste. Se specifichi due gruppi di destinazioni, uno con un peso di 10 e l'altro con un peso di 20, il gruppo di destinazioni con un peso di 20 riceve il doppio delle richieste rispetto all'altro gruppo di destinazioni.
Se configuri una regola per distribuire il traffico tra gruppi target ponderati e uno dei gruppi target è vuoto o contiene solo obiettivi non integri, il sistema di bilanciamento del carico non esegue automaticamente il failover su un gruppo target con obiettivi integri.
**Sessioni permanenti e gruppi target ponderati**
Per impostazione predefinita, la configurazione di una regola per distribuire il traffico tra gruppi di destinazioni ponderati non garantisce che le sticky session vengano rispettate. Per garantire che le sticky session siano rispettate, abilitare la persistenza del gruppo di destinazioni per la regola. Quando il load balancer indirizza per la prima volta una richiesta a un gruppo target ponderato, genera un cookie denominato AWSALBTG che codifica le informazioni sul gruppo target selezionato, crittografa il cookie e include il cookie nella risposta al client. Il client deve includere il cookie ricevuto nelle richieste successive al sistema di bilanciamento del carico. Quando il sistema di bilanciamento del carico riceve una richiesta che corrisponde a una regola con la persistenza del gruppo di destinazioni abilitata e contiene il cookie, la richiesta viene instradata al gruppo di destinazioni specificato nel cookie.
Gli Application Load Balancer non supportano i valori dei cookie codificati con URL.
Con le richieste CORS (cross-origin resource sharing), alcuni browser richiedono a `SameSite=None; Secure` di abilitare la stickness. In questo caso, Elastic Load Balancing genera un secondo cookie AWSALBTGCORS, che include le stesse informazioni dello stickiness cookie originale più questo attributo. `SameSite` I clienti ricevono entrambi i cookie.
### Esempio di operazione di inoltro con un gruppo di destinazioni
Puoi specificare un’operazione quando crei o modifichi una regola. Per ulteriori informazioni consulta i comandi [create-rule](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-rule.html) e [modify-rule](https://docs.aws.amazon.com/cli/latest/reference/elbv2/modify-rule.html). La seguente operazione inoltra le richieste al gruppo di destinazioni specificato.
```
[
{
"Type": "forward",
"ForwardConfig": {
"TargetGroups": [
{
"TargetGroupArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/my-targets/73e2d6bc24d8a067"
}
]
}
}
]
```
### Esempio di azione diretta con gruppi target ponderati
L'operazione seguente inoltra le richieste ai due gruppi di destinazioni specificati, in base al peso di ciascun gruppo di destinazioni.
```
[
{
"Type": "forward",
"ForwardConfig": {
"TargetGroups": [
{
"TargetGroupArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/blue-targets/73e2d6bc24d8a067",
"Weight": 10
},
{
"TargetGroupArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/green-targets/09966783158cda59",
"Weight": 20
}
]
}
}
]
```
### Esempio di operazione di inoltro con persistenza abilitata
Se si dispone di un'operazione di inoltro con più gruppi di destinazioni e per uno o più gruppi di destinazioni sono abilitate le [sessioni permanenti](edit-target-group-attributes.md#sticky-sessions), è necessario abilitare la persistenza del gruppo di destinazioni.
L'operazione seguente inoltra le richieste ai due gruppi di destinazioni specificati, con la persistenza del gruppo di destinazioni abilitata. Le richieste che non contengono il cookie AWSALBTG vengono instradate in base al peso di ciascun gruppo di destinazioni.
```
[
{
"Type": "forward",
"ForwardConfig": {
"TargetGroups": [
{
"TargetGroupArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/blue-targets/73e2d6bc24d8a067",
"Weight": 10
},
{
"TargetGroupArn": "arn:aws:elasticloadbalancing:us-west-2:123456789012:targetgroup/green-targets/09966783158cda59",
"Weight": 20
}
],
"TargetGroupStickinessConfig": {
"Enabled": true,
"DurationSeconds": 1000
}
}
}
]
```
## Operazioni di reindirizzamento
Un'`redirect`azione reindirizza le richieste dei client da un URL a un altro. È possibile configurare i reindirizzamenti come temporanei (HTTP 302) o permanenti (HTTP 301) in base alle esigenze.
Un URI è costituito dai componenti seguenti:
```
protocol://hostname:port/path?query
```
È necessario modificare almeno uno dei componenti seguenti per evitare un reindirizzamento loop: protocollo, nome host, porta o percorso. I componenti che non vengono modificati mantengono i loro valori originali.
*protocol*
Il protocollo (HTTP o HTTPS). È possibile reindirizzare i protocolli HTTP a HTTP, HTTP a HTTPS e HTTPS a HTTPS. Non è possibile reindirizzare i protocolli HTTPS a HTTP.
*hostname*
Il nome host. Il nome host non prevede la distinzione tra lettere maiuscole e minuscole, può contenere fino a 128 caratteri di lunghezza e può contenere caratteri alfanumerici, caratteri jolly (\$1 e ?) e trattini (-).
*port*
La porta (da 1 a 65535).
*path*
Il percorso assoluto, partendo da "/". Il percorso prevede la distinzione tra lettere maiuscole e minuscole, può contenere fino a 128 caratteri di lunghezza e può contenere caratteri alfanumerici, caratteri jolly (\$1 e ?), & (con &) e i seguenti caratteri speciali: \$1-.\$1/\$1"'@:\$1
*query*
I parametri di query La lunghezza massima è 128 caratteri.
È possibile riutilizzare i componenti URI dell'URL originale nell'URL di destinazione utilizzando le seguenti parole chiave riservate:
+ `#{protocol}` - Mantiene il protocollo. Utilizzare nel protocollo e nei componenti query.
+ `#{host}` - Mantiene il dominio. Utilizzare nel nome host, nel percorso e nei componenti query.
+ `#{port}` - Mantiene la porta. Utilizzare nella porta, nel percorso e nei componenti query.
+ `#{path}` - Mantiene il percorso. Utilizzare nel percorso e nei componenti query.
+ `#{query}` - Mantiene i parametri di query. Utilizzare nel componente query.
Quando viene eseguita un'operazione `redirect`, l'operazione viene registrata nei log di accesso. Per ulteriori informazioni, consulta [Voci dei log di accesso](load-balancer-access-logs.md#access-log-entry-format). Il conteggio delle operazioni `redirect` avvenute con successo viene segnalato dal parametro `HTTP_Redirect_Count`. Per ulteriori informazioni, consulta [Parametri di Application Load Balancer](load-balancer-cloudwatch-metrics.md#load-balancer-metrics-alb).
### Esempio di operazioni di reindirizzamento tramite la console
**Reindirizza tramite HTTPS e la porta 40443**
Ad esempio, la regola seguente consente di configurare un reindirizzamento permanente a un URL che usa il protocollo HTTPS e la porta specificata (40443), ma mantiene il nome host, il percorso e i parametri di query originali. Questa schermata è equivalente a "https://\$1\$1host\$1:40443/\$1\$1path\$1?\$1\$1query\$1".
![\[Una regola che reindirizza la richiesta a un URL che usa il protocollo HTTPS e la porta specificata (40443), ma mantiene il dominio, il percorso e i parametri di query originali dell'URL originale.\]](http://docs.aws.amazon.com/it_it/elasticloadbalancing/latest/application/images/redirect_https_port.png)
**Reindirizza utilizzando un percorso modificato**
La regola seguente consente di configurare un reindirizzamento permanente a un URL che mantiene il protocollo, la porta, il nome host e i parametri di query originali e utilizza la parola chiave `#{path}` per creare un percorso modificato. Questa schermata è equivalente a "\$1\$1protocol\$1://\$1\$1host\$1:\$1\$1port\$1/new/\$1\$1path\$1?\$1\$1query\$1".
![\[Una regola che consente di reindirizzare la richiesta a un URL che mantiene il protocollo, la porta, il nome host e i parametri di query originali e utilizza la parola chiave #{path} per creare un percorso modificato.\]](http://docs.aws.amazon.com/it_it/elasticloadbalancing/latest/application/images/redirect_path.png)
### Esempi di azioni di reindirizzamento utilizzando AWS CLI
**Reindirizzamento tramite HTTPS e la porta 40443**
Puoi specificare un’operazione quando crei o modifichi una regola. Per ulteriori informazioni consulta i comandi [create-rule](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-rule.html) e [modify-rule](https://docs.aws.amazon.com/cli/latest/reference/elbv2/modify-rule.html). La seguente azione reindirizza una richiesta HTTP a una richiesta HTTP sulla porta 443, con lo stesso nome host, percorso e stringa di query della richiesta HTTOP:
```
--actions '[{
"Type": "redirect",
"RedirectConfig": {
"Protocol": "HTTPS",
"Port": "443",
"Host": "#{host}",
"Path": "/#{path}",
"Query": "#{query}",
"StatusCode": "HTTP_301"
}
}]'
```
# Tipi di condizioni per le regole del listener
Le condizioni definiscono i criteri che le richieste in entrata devono soddisfare affinché una regola del listener abbia effetto. Se una richiesta soddisfa le condizioni di una regola, la richiesta viene gestita come specificato dalle azioni della regola. Ogni condizione della regola ha informazioni su tipo e configurazione. Gli Application Load Balancer supportano i seguenti tipi di condizioni per le regole del listener.Tipi di condizioni
`host-header`
Instradamento basato sul nome host di ogni richiesta. Per ulteriori informazioni, consulta [Condizioni host](#host-conditions).
`http-header`
Instradamento basato sulle intestazioni HTTP per ogni richiesta. Per ulteriori informazioni, consulta [Condizioni nell'intestazione HTTP](#http-header-conditions).
`http-request-method`
Instradamento basato sul metodo della richiesta HTTP di ogni richiesta. Per ulteriori informazioni, consulta [Condizioni del metodo di richiesta HTTP](#http-request-method-conditions).
`path-pattern`
Percorso basato sui modelli di percorso indicati nella richiesta URLs. Per ulteriori informazioni, consulta [Condizioni percorso](#path-conditions).
`query-string`
Percorso basato su key/value coppie o valori nelle stringhe di query. Per ulteriori informazioni, consulta [Condizioni delle stringhe di query](#query-string-conditions).
`source-ip`
Instradamento basato sull’indirizzo IP di origine di ogni richiesta. Per ulteriori informazioni, consulta [Condizioni indirizzo IP di origine](#source-ip-conditions).
**Nozioni di base sulle condizioni**
+ Ogni regola può facoltativamente includere zero o una di ciascuna delle seguenti condizioni:`host-header`, `http-request-method``path-pattern`, e. `source-ip` Ogni regola può inoltre includere zero o più di ciascuna delle seguenti condizioni: `http-header` e`query-string`.
+ Con le `path-pattern` condizioni `host-header``http-header`, e, è possibile utilizzare la corrispondenza dei valori o la corrispondenza delle espressioni regolari (regex).
+ Puoi specificare fino a tre valutazioni di corrispondenze per condizione. Ad esempio, per ogni condizione `http-header` è possibile specificare fino a tre stringhe da paragonare al valore dell’intestazione HTTP nella richiesta. La condizione è soddisfatta se una delle stringhe corrisponde al valore dell’intestazione HTTP. Per fare in modo che tutte le stringhe siano una corrispondenza, crea una condizione per valutazione di corrispondenza.
+ Puoi specificare fino a cinque valutazioni di corrispondenze per regola. Ad esempio, puoi creare una regola con cinque condizioni in cui ogni condizione ha una valutazione di corrispondenza.
+ Nelel valutazioni di corripondenza è possibile includere caratteri jolly per le condizioni `http-header`,`host-header`, `path-pattern` e `query-string`. Esiste un limite di cinque caratteri jolly per regola.
+ Le regole vengono applicate solo ai caratteri ASCII visibili; i caratteri di controllo (da 0x00 a 0x1f e 0x7f) sono esclusi.
**Demo**
Per le demo, consulta [Instradamento avanzato delle richieste](https://exampleloadbalancer.com/advanced_request_routing_demo.html).
## Condizioni host
È possibile utilizzare le condizioni host per definire regole in grado di inoltrare le richieste in base al nome host nell'intestazione host (noto anche come *instradamento basato su host*). In questo modo è possibile supportare più sottodomini e domini di primo livello diversi utilizzando un singolo sistema di bilanciamento del carico.
Un nome host non distingue tra maiuscole e minuscole, può avere una lunghezza massima di 128 caratteri e contenere qualsiasi carattere tra i seguenti:
+ A-Z, a-z, 0-9
+ - .
+ \$1 (corrisponde a 0 o più caratteri)
+ ? (corrisponde esattamente a 1 carattere)
Si deve includere il carattere "." almeno una volta. Dopo l'ultimo carattere "." è possibile includere solo caratteri alfabetici.
**Esempio di nomi host**
+ example.com
+ test.example.com
+ \$1.example.com
La regola \$1.example.com si applica a test.example.com ma non a example.com.
**Example Esempio di condizione dell'intestazione dell'host**
Puoi specificare le condizioni quando crei o modifichi una regola. Per ulteriori informazioni consulta i comandi [create-rule](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-rule.html) e [modify-rule](https://docs.aws.amazon.com/cli/latest/reference/elbv2/modify-rule.html).
```
[
{
"Field": "host-header",
"HostHeaderConfig": {
"Values": ["*.example.com"]
}
}
]
```
```
[
{
"Field": "host-header",
"HostHeaderConfig": {
"RegexValues": ["^(.*)\\.example\\.com$"]
}
}
]
```
## Condizioni nell'intestazione HTTP
Puoi usare le condizioni dell’intestazione HTTP per configurare le regole che instradano le richieste in base alle intestazioni HTTP per la richiesta. Puoi specificare i nomi dei campi delle intestazioni HTTP standard o personalizzate. Il nome dell'intestazione e la valutazione della corrispondenza non fanno distinzione tra lettere maiuscole e minuscole. I seguenti caratteri jolly sono supportati nelle stringhe di confronto: \$1 (corrisponde a 0 o a più caratteri) e ? (corrisponde esattamente a 1 carattere). I caratteri jolly non sono supportati nel nome dell’intestazione.
Quando l'attributo Application Load Balancer `routing.http.drop_invalid_header_fields` è abilitato, eliminerà i nomi delle intestazioni che non sono conformi alle espressioni regolari (). `A-Z,a-z,0-9` È inoltre possibile aggiungere nomi di intestazione non conformi alle espressioni regolari.
**Example Esempio di condizione di intestazione HTTP**
Puoi specificare le condizioni quando crei o modifichi una regola. Per ulteriori informazioni consulta i comandi [create-rule](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-rule.html) e [modify-rule](https://docs.aws.amazon.com/cli/latest/reference/elbv2/modify-rule.html). La seguente condizione è soddisfatta dalle richieste con un’intestazione Utente-Agente che corrisponde a una delle stringhe specificate.
```
[
{
"Field": "http-header",
"HttpHeaderConfig": {
"HttpHeaderName": "User-Agent",
"Values": ["*Chrome*", "*Safari*"]
}
}
]
```
```
[
{
"Field": "http-header",
"HttpHeaderConfig": {
"HttpHeaderName": "User-Agent",
"RegexValues": [".+"]
}
}
]
```
## Condizioni del metodo di richiesta HTTP
Puoi usare le condizioni del metodo di richiesta HTTP per configurare le regole che instradano le richieste in base al metodo di richiesta HTTP della richiesta. Puoi specificare metodi HTTP standard o personalizzati. La valutazione della corrispondenza prevede la distinzione tra lettere maiuscole e minuscole. I caratteri jolly non sono supportati; pertanto, il nome del metodo deve essere una corrispondenza esatta.
Consigliamo di instradare le richieste GET e HEAD nello stesso modo, perché la risposta alla richiesta HEAD può essere inserita nella cache.
**Example Esempio di condizione del metodo HTTP**
Puoi specificare le condizioni quando crei o modifichi una regola. Per ulteriori informazioni consulta i comandi [create-rule](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-rule.html) e [modify-rule](https://docs.aws.amazon.com/cli/latest/reference/elbv2/modify-rule.html). La condizione seguente è soddisfatta dalle richieste che utilizzano il metodo specificato.
```
[
{
"Field": "http-request-method",
"HttpRequestMethodConfig": {
"Values": ["CUSTOM-METHOD"]
}
}
]
```
## Condizioni percorso
È possibile utilizzare le condizioni percorso per definire regole in grado di inoltrare le richieste in base all'URL nella richiesta (noto anche come *instradamento basato su host*).
Il modello di percorso viene applicato solo al percorso dell'URL, non ai suoi parametri di query. Viene applicato solo ai caratteri ASCII visibili; i caratteri di controllo (da 0x00 a 0x1f e 0x7f) sono esclusi.
La valutazione della regola viene eseguita solo dopo la normalizzazione dell'URI.
Un modello di percorso non distingue tra maiuscole e minuscole, può avere una lunghezza massima di 128 caratteri e contenere qualsiasi carattere tra i seguenti.
+ A-Z, a-z, 0-9
+ \$1 - . \$1 / \$1 " ' @ : \$1
+ & (utilizzo di &)
+ \$1 (corrisponde a 0 o più caratteri)
+ ? (corrisponde esattamente a 1 carattere)
Se la versione del protocollo è gRPC, le condizioni possono essere specifiche per un pacchetto, un servizio o un metodo.
**Esempio di modelli di percorso HTTP**
+ `/img/*`
+ `/img/*/pics`
**Esempio di modelli di percorso gRPC**
+ /package
+ /package.service
+ /package.service/method
Il modello di percorso viene utilizzato per instradare le richieste, ma non le modifica. Ad esempio, se una regola ha un modello di percorso `/img/*`, la regola inoltra una richiesta per `/img/picture.jpg` al gruppo target specificato come una richiesta per `/img/picture.jpg`.
**Example Esempio di condizione del modello di percorso**
Puoi specificare le condizioni quando crei o modifichi una regola. Per ulteriori informazioni consulta i comandi [create-rule](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-rule.html) e [modify-rule](https://docs.aws.amazon.com/cli/latest/reference/elbv2/modify-rule.html). La seguente condizione è soddisfatta dalle richieste con un URL che contiene la stringa specificata.
```
[
{
"Field": "path-pattern",
"PathPatternConfig": {
"Values": ["/img/*"]
}
}
]
```
```
[
{
"Field": "path-pattern",
"PathPatternConfig": {
"RegexValues": ["^\\/api\\/(.*)$"]
}
}
]
```
## Condizioni delle stringhe di query
È possibile utilizzare le condizioni della stringa di query per configurare le regole che instradano le richieste in base a key/value coppie o valori nella stringa di query. La valutazione della corrispondenza non prevede la distinzione tra lettere maiuscole e minuscole. I seguenti caratteri jolly sono supportati: \$1 (corrisponde a 0 o a più caratteri) e ? (corrisponde esattamente a 1 carattere).
**Example Esempio di condizione della stringa di query**
Puoi specificare le condizioni quando crei o modifichi una regola. Per ulteriori informazioni consulta i comandi [create-rule](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-rule.html) e [modify-rule](https://docs.aws.amazon.com/cli/latest/reference/elbv2/modify-rule.html). La seguente condizione è soddisfatta dalle richieste con una stringa di query che include una key/value coppia di «version=v1" o qualsiasi chiave impostata su «example».
```
[
{
"Field": "query-string",
"QueryStringConfig": {
"Values": [
{
"Key": "version",
"Value": "v1"
},
{
"Value": "*example*"
}
]
}
}
]
```
## Condizioni indirizzo IP di origine
Puoi usare le condizioni dell’indirizzo IP di origine per configurare le regole che instradano le richieste in base all’indirizzo IP di origine della richiesta. L’indirizzo IP deve essere in formato CIDR. È possibile utilizzare entrambi gli indirizzi. IPv4 IPv6 I caratteri jolly non sono supportati. Non è possibile specificare il CIDR `255.255.255.255/32` come condizione della regola dell'IP di origine.
Se un client è al di là di un proxy, si tratta dell'indirizzo IP del proxy, non dell'indirizzo IP del client.
Questa condizione non è soddisfatta dagli indirizzi nell' X-Forwarded-Forintestazione. Per cercare gli indirizzi nell' X-Forwarded-Forintestazione, utilizza una `http-header` condizione.
**Example Esempio di condizione IP di origine**
Puoi specificare le condizioni quando crei o modifichi una regola. Per ulteriori informazioni consulta i comandi [create-rule](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-rule.html) e [modify-rule](https://docs.aws.amazon.com/cli/latest/reference/elbv2/modify-rule.html). La seguente condizione è soddisfatta dalle richieste con un indirizzo IP di origine in uno dei blocchi CIDR specificati.
```
[
{
"Field": "source-ip",
"SourceIpConfig": {
"Values": ["192.0.2.0/24", "198.51.100.10/32"]
}
}
]
```
# Trasformazioni per le regole degli ascoltatori
Una trasformazione delle regole riscrive le richieste in entrata prima che vengano indirizzate alle destinazioni. La riscrittura di una richiesta non modifica la decisione di routing presa durante la valutazione delle condizioni della regola. Ciò è utile quando i client inviano un URL o un'intestazione host diversi da quelli previsti dai destinatari.
L'utilizzo delle trasformazioni delle regole trasferisce la responsabilità della modifica di percorsi, stringhe di query e intestazioni degli host al sistema di bilanciamento del carico. Ciò elimina la necessità di aggiungere una logica di modifica personalizzata al codice dell'applicazione o di affidarsi a un proxy di terze parti per eseguire le modifiche.
Gli Application Load Balancer supportano le seguenti trasformazioni per le regole dei listener.Trasformazioni
`host-header-rewrite`
Riscrive l'intestazione dell'host nella richiesta. La trasformazione utilizza un'espressione regolare per corrispondere a un pattern nell'intestazione dell'host e quindi la sostituisce con una stringa sostitutiva.
`url-rewrite`
Riscrive l'URL della richiesta. La trasformazione utilizza un'espressione regolare per corrispondere a un modello nell'URL della richiesta e quindi la sostituisce con una stringa sostitutiva.
**Nozioni di base sulla trasformazione**
+ Puoi aggiungere una trasformazione di riscrittura dell'intestazione dell'host e una trasformazione di riscrittura dell'URL per regola.
+ Non è possibile aggiungere una trasformazione a una regola predefinita.
+ Se non c'è alcuna corrispondenza tra i modelli, la richiesta originale viene inviata alla destinazione.
+ Se c'è una corrispondenza tra i modelli ma la trasformazione fallisce, restituiamo un errore HTTP 500.
## Trasformazioni di riscrittura dell'intestazione dell'host
È possibile modificare il nome di dominio specificato nell'intestazione dell'host.
**Example Esempio di trasformazione dell'intestazione dell'host**
È possibile specificare una trasformazione quando si crea o si modifica una regola. Per ulteriori informazioni consulta i comandi [create-rule](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-rule.html) e [modify-rule](https://docs.aws.amazon.com/cli/latest/reference/elbv2/modify-rule.html). Di seguito è riportato un esempio di trasformazione dell'intestazione dell'host. Trasforma l'intestazione dell'host in un endpoint interno.
```
[
{
"Type": "host-header-rewrite",
"HostHeaderRewriteConfig": {
"Rewrites": [
{
"Regex": "^mywebsite-(.+).com$",
"Replace": "internal.dev.$1.myweb.com"
}
]
}
}
]
```
Ad esempio, questa trasformazione riscrive l'intestazione dell'host come. `https://mywebsite-example.com/project-a` `https://internal.dev.example.myweb.com/project-a`
## Trasformazioni di riscrittura degli URL
È possibile modificare il percorso o la stringa di query dell'URL. Riscrivendo l'URL a livello di load balancer, il frontend URLs può rimanere coerente per utenti e motori di ricerca anche se i servizi di backend cambiano. Puoi anche semplificare stringhe di query URL complesse per facilitarne la digitazione da parte dei clienti.
Tieni presente che non puoi modificare il protocollo o la porta dell'URL, ma solo il percorso e la stringa di query.
**Example Esempio di trasformazione di riscrittura dell'URL**
È possibile specificare una trasformazione quando si crea o si modifica una regola. Per ulteriori informazioni consulta i comandi [create-rule](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-rule.html) e [modify-rule](https://docs.aws.amazon.com/cli/latest/reference/elbv2/modify-rule.html). Di seguito è riportato un esempio di trasformazione di riscrittura di un URL. Trasforma la struttura della directory in una stringa di query.
```
[
{
"Type": "url-rewrite",
"UrlRewriteConfig": {
"Rewrites": [
{
"Regex": "^/dp/([A-Za-z0-9]+)/?$",
"Replace": "/product.php?id=$1"
}
]
}
}
]
```
Ad esempio, questa trasformazione riscrive l'URL `https://www.example.com/dp/B09G3HRMW` della richiesta come. `https://www.example.com/product.php?id=B09G3HRMW`
**Il modo in cui le riscritture degli URL differiscono dai reindirizzamenti degli URL**
| Caratteristica | Reindirizzamenti URL | Riscritture degli URL |
| --- | --- | --- |
| Visualizzazione dell'URL | Modifiche nella barra degli indirizzi del browser | Nessuna modifica nella barra degli indirizzi del browser |
| Codici di stato | Utilizza 301 (permanente) o 302 (temporaneo) | Nessuna modifica del codice di stato |
| Processing | Lato browser | Lato server |
| Usi comuni | Modifica del dominio, consolidamento del sito Web, correzione dei collegamenti interrotti | Pulisci URLs per la SEO, nascondi strutture complesse, fornisci una mappatura degli URL legacy |
# Aggiungi una regola listener per il tuo Application Load Balancer
Definisci una regola predefinita quando crei un listener. È possibile definire regole aggiuntive in qualsiasi momento. Ogni regola deve specificare un'azione e una condizione e può facoltativamente specificare trasformazioni. Per ulteriori informazioni, consulta gli argomenti seguenti:
+ [Tipi di operazione](rule-action-types.md)
+ [Tipi di condizioni](rule-condition-types.md)
+ [Trasformazioni](rule-transforms.md)
------
#### [ Console ]
**Per aggiungere una regola**
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Seleziona **Sistemi di bilanciamento del carico** nel riquadro di navigazione.
1. Selezionare il load balancer.
1. Nella scheda **Ascoltatori e regole**, seleziona il testo nella colonna **Protocollo:Porta** per aprire la pagina dei dettagli dell'ascoltatore.
1. Nella scheda **Regole** scegliere **Aggiungi regola**.
1. (Facoltativo) Per specificare un nome per la regola, espandi **Nome e tag e** inserisci il nome. Per aggiungere altri tag, scegli **Aggiungi tag aggiuntivi** e inserisci la chiave del tag e il valore del tag.
1. Per ogni condizione, scegli **Aggiungi condizione**, scegli il tipo di condizione e fornisci i valori di condizione richiesti:
+ **Intestazione host**: seleziona il tipo di pattern di corrispondenza e inserisci l'intestazione dell'host.
**Corrispondenza dei valori**: massimo 128 caratteri. Non prevede una distinzione tra lettere maiuscole e minuscole. I caratteri consentiti sono a-z, A-Z, 0-9, i caratteri speciali -\$1. e i caratteri jolly (\$1 e ?). Si deve includere il carattere "." almeno una volta. Dopo l'ultimo carattere "." è possibile includere solo caratteri alfabetici.
**Corrispondenza regex**: massimo 128 caratteri.
+ **Percorso**: seleziona il tipo di modello di corrispondenza e inserisci il percorso.
**Corrispondenza dei valori**: massimo 128 caratteri. Distinzione tra lettere maiuscole e minuscole. I caratteri consentiti sono a-z, A-Z, 0-9, i caratteri speciali \$1-.\$1/\$1"'@:\$1; & e i caratteri jolly (\$1 e ?).
**Corrispondenza regex**: massimo 128 caratteri.
+ **Stringa di query**: immettete coppie chiave:valore o valori senza chiavi.
Massimo 128 caratteri. Non prevede una distinzione tra lettere maiuscole e minuscole. I caratteri consentiti sono a-z, A-Z, 0-9, i caratteri speciali \$1-.\$1/\$1"'@:\$1&()\$1,;= e i caratteri jolly (\$1 e ?).
+ **Metodo di richiesta HTTP**: immettere il metodo di richiesta HTTP.
Massimo 40 caratteri. Distinzione tra lettere maiuscole e minuscole. I caratteri consentiti sono A-Z e i caratteri speciali -\$1. I caratteri jolly non sono supportati.
+ **Intestazione HTTP**: seleziona il tipo di modello di corrispondenza e inserisci il nome dell'intestazione e le stringhe di confronto.
+ **Nome dell'intestazione HTTP**: la regola valuterà le richieste che contengono questa intestazione per confermare i valori corrispondenti.
**Corrispondenza dei valori**: massimo 40 caratteri. Non prevede una distinzione tra lettere maiuscole e minuscole. I caratteri consentiti sono a-z, A-Z, 0-9 e i caratteri speciali \$1?-\$1\$1\$1%&'\$1.^\$1`\$1\$1. I caratteri jolly non sono supportati.
**Corrispondenza regex**: massimo 128 caratteri.
+ **Valore dell'intestazione HTTP**: inserire stringhe da confrontare rispetto al valore dell'intestazione HTTP.
**Valore corrispondente**: massimo 128 caratteri. Non prevede una distinzione tra lettere maiuscole e minuscole. I caratteri consentiti sono a-z, A-Z, 0-9; gli spazi; i seguenti caratteri speciali:\$1» \$1\$1%&' () \$1,. /:; <=>@ [] ^\$1` \$1\$1\$1 \$1-; e caratteri jolly (\$1 e?).
**Corrispondenza Regex**: massimo 128 caratteri.
+ **IP sorgente**: definire l'indirizzo IP sorgente in formato CIDR. Entrambi IPv4 IPv6 CIDRs sono consentiti. I caratteri jolly non sono supportati.
1. (Facoltativo) Per aggiungere una trasformazione, **scegliete Aggiungi trasformazione**, scegliete il tipo di trasformazione e immettete un'espressione regolare da abbinare e una stringa sostitutiva.
1. (Facoltativo, solo listener HTTPS) Per l'**azione di pre-routing**, selezionate una delle seguenti azioni:
+ **Autentica utente**: scegli un provider di identità e fornisci le informazioni richieste. Per ulteriori informazioni, consulta [Autenticazione degli utenti tramite Application Load Balancer](listener-authenticate-users.md).
+ **Token di convalida**: inserisci l'endpoint JWKS, i problemi e qualsiasi altra dichiarazione. Per ulteriori informazioni, consulta [Verifica JWTs utilizzando un Application Load Balancer](listener-verify-jwt.md).
1. Per l'**azione di routing**, seleziona una delle seguenti azioni:
+ **Inoltra ai gruppi target**: scegli un gruppo target. Per aggiungere un altro gruppo target, scegli **Aggiungi gruppo target**, scegli un gruppo target, rivedi i pesi relativi e aggiorna i pesi secondo necessità. Devi abilitare la fedeltà a livello di gruppo se l'hai abilitata su uno qualsiasi dei gruppi target.
+ **Reindirizza all'URL****: inserisci l'URL inserendo ogni parte separatamente nella scheda **Parti URI** o inserendo l'indirizzo completo nella scheda URL completo.** Per il **codice di stato**, selezionate temporaneo (HTTP 302) o permanente (HTTP 301) in base alle vostre esigenze.
+ **Restituisci una risposta fissa**: inserisci il **codice di risposta** da restituire in caso di mancata risposta alle richieste dei client. Facoltativamente, puoi specificare il **tipo di contenuto** e il **corpo della risposta**.
1. Scegli **Next (Successivo)**.
1. Per **Priorità**, inserisci un valore compreso tra 1 e 50.000. Le regole vengono valutate in ordine di priorità dal valore più basso a quello più alto.
1. Scegli **Next (Successivo)**.
1. Nella pagina **Rivedi e crea**, scegli **Crea**.
------
#### [ AWS CLI ]
**Per aggiungere una regola**
Usa il comando [create-rule](https://docs.aws.amazon.com/cli/latest/reference/elbv2/create-rule.html).
L'esempio seguente crea una regola con un'`forward`azione e una `host-header` condizione.
```
aws elbv2 create-rule \
--listener-arn listener-arn \
--priority 10 \
--conditions "Field=host-header,Values=example.com,www.example.com" \
--actions "Type=forward,TargetGroupArn=target-group-arn"
```
Per creare un'azione di inoltro che distribuisca il traffico tra due gruppi target, utilizzate invece la seguente `--actions` opzione.
```
--actions '[{
"Type":"forward",
"ForwardConfig":{
"TargetGroups":[
{"TargetGroupArn":"target-group-1-arn","Weight":50},
{"TargetGroupArn":"target-group-2-arn","Weight":50}
]
}
}]'
```
L'esempio seguente crea una regola con un'`fixed-response`azione e una `source-ip` condizione.
```
aws elbv2 create-rule \
--listener-arn listener-arn \
--priority 20 \
--conditions '[{"Field":"source-ip","SourceIpConfig":{"Values":["192.168.1.0/24","10.0.0.0/16"]}}]' \
--actions "Type=fixed-response,FixedResponseConfig={StatusCode=403,ContentType=text/plain,MessageBody='Access denied'}"
```
L'esempio seguente crea una regola con un'`redirect`azione e una `http-header` condizione.
```
aws elbv2 create-rule \
--listener-arn listener-arn \
--priority 30 \
--conditions '[{"Field":"http-header","HttpHeaderConfig":{"HttpHeaderName":"User-Agent","Values":["*Mobile*","*Android*","*iPhone*"]}}]' \
--actions "Type=redirect,RedirectConfig={Host=m.example.com,StatusCode=HTTP_302}"
```
------
#### [ CloudFormation ]
**Per aggiungere una regola**
Definire un tipo di risorsa [AWS::ElasticLoadBalancingV2::ListenerRule](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-listenerrule.html).
L'esempio seguente crea una regola con un'`forward`azione e una `host-header` condizione. La regola invia il traffico al gruppo target specificato quando viene soddisfatta la condizione.
```
Resources:
myForwardListenerRule:
Type: 'AWS::ElasticLoadBalancingV2::ListenerRule'
Properties:
ListenerArn: !Ref myListener
Priority: 10
Conditions:
- Field: host-header
Values:
- example.com
- www.example.com
Actions:
- Type: forward
TargetGroupArn: !Ref myTargetGroup
```
In alternativa, per creare un'azione di inoltro che distribuisca il traffico tra due gruppi target quando viene soddisfatta la condizione, definisci `Actions` quanto segue.
```
Actions:
- Type: forward
ForwardConfig:
TargetGroups:
- TargetGroupArn: !Ref TargetGroup1
Weight: 50
- TargetGroupArn: !Ref TargetGroup2
Weight: 50
```
L'esempio seguente crea una regola con un'`fixed-response`azione e una `source-ip` condizione.
```
Resources:
myFixedResponseListenerRule:
Type: 'AWS::ElasticLoadBalancingV2::ListenerRule'
Properties:
ListenerArn: !Ref myListener
Priority: 20
Conditions:
- Field: source-ip
SourceIpConfig:
Values:
- 192.168.1.0/24
- 10.0.0.0/16
Actions:
- Type: fixed-response
FixedResponseConfig:
StatusCode: 403
ContentType: text/plain
MessageBody: "Access denied"
```
L'esempio seguente crea una regola con un'`redirect`azione e una `http-header` condizione.
```
Resources:
myRedirectListenerRule:
Type: 'AWS::ElasticLoadBalancingV2::ListenerRule'
Properties:
ListenerArn: !Ref myListener
Priority: 30
Conditions:
- Field: http-header
HttpHeaderConfig:
HttpHeaderName: User-Agent
Values:
- "*Mobile*"
- "*Android*"
- "*iPhone*"
Actions:
- Type: redirect
RedirectConfig:
Host: m.example.com
StatusCode: HTTP_302
```
------
# Modifica una regola di ascolto per il tuo Application Load Balancer
È possibile modificare l'azione e le condizioni per una regola del listener in qualsiasi momento. Gli aggiornamenti delle regole non hanno effetto immediato, pertanto è possibile che le richieste vengano instradate utilizzando la configurazione della regola precedente per un breve periodo dopo l'aggiornamento di una regola. Eventuali richieste in transito vengono completate.
**Topics**
+ [Modifica l'azione predefinita](#modify-default-action)
+ [Aggiorna le priorità delle regole](#update-rule-priority)
+ [Aggiorna azioni, condizioni e trasformazioni](#update-rule-actions-conditions-transforms)
+ [Gestisci i tag delle regole](#manage-rule-tags)
## Modifica l'azione predefinita
L'azione predefinita è assegnata a una regola denominata **Default**. È possibile mantenere il tipo di regola corrente e modificare le informazioni richieste oppure modificare il tipo di regola e fornire le nuove informazioni richieste.
------
#### [ Console ]
**Per modificare l'azione predefinita**
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Seleziona **Sistemi di bilanciamento del carico** nel riquadro di navigazione.
1. Selezionare il load balancer.
1. Nella scheda **Ascoltatori e regole**, seleziona il testo nella colonna **Protocollo:Porta** per aprire la pagina dei dettagli dell'ascoltatore.
1. Nella scheda **Regole**, nella sezione **Regole del listener**, seleziona la regola predefinita. Scegli **Azioni**, **Modifica regola**.
1. In **Azione predefinita**, aggiorna le azioni in base alle esigenze.
------
#### [ AWS CLI ]
**Per modificare l'azione predefinita**
Utilizza il comando [modify-listener](https://docs.aws.amazon.com/cli/latest/reference/elbv2/modify-listener.html). L'esempio seguente aggiorna il gruppo target per l'`forward`azione.
```
aws elbv2 modify-listener \
--listener-arn listener-arn \
--default-actions Type=forward,TargetGroupArn=new-target-group-arn
```
L'esempio seguente aggiorna l'azione predefinita per distribuire equamente il traffico tra due gruppi target.
```
aws elbv2 modify-listener \
--listener-arn listener-arn \
--default-actions '[{
"Type":"forward",
"ForwardConfig":{
"TargetGroups":[
{"TargetGroupArn":"target-group-1-arn","Weight":50},
{"TargetGroupArn":"target-group-2-arn","Weight":50}
]
}
}]'
```
------
#### [ CloudFormation ]
**Per modificare l'azione predefinita**
Aggiorna la [AWS::ElasticLoadBalancingV2::Listener](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-listener.html)risorsa.
```
Resources:
myHTTPlistener:
Type: 'AWS::ElasticLoadBalancingV2::Listener'
Properties:
LoadBalancerArn: !Ref myLoadBalancer
Protocol: HTTP
Port: 80
DefaultActions:
- Type: "forward"
TargetGroupArn: !Ref myNewTargetGroup
```
------
## Aggiorna le priorità delle regole
Le regole vengono valutate in base all’ordine di priorità, dal valore più basso a quello più alto. La regola predefinita è valutata per ultima. È possibile modificare la priorità di una regola non predefinita in qualsiasi momento. Non è possibile modificare la priorità della regola predefinita.
------
#### [ Console ]
**Per aggiornare le priorità delle regole**
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Selezionare **Sistemi di bilanciamento del carico** nel riquadro di navigazione.
1. Selezionare il load balancer.
1. Nella scheda **Ascoltatori e regole**, seleziona il testo nella colonna **Protocollo:Porta** per aprire la pagina dei dettagli dell'ascoltatore.
1. Nella scheda **Regole**, seleziona la regola del listener, quindi scegli **Azioni**, **Riassegna priorità alle** regole.
1. Nella sezione **Regole del listener**, la colonna **Priorità mostra le priorità correnti** delle regole. Per aggiornare la priorità di una regola, inserisci un valore compreso tra 1 e 50.000.
1. Scegli **Save changes** (Salva modifiche).
------
#### [ AWS CLI ]
**Per aggiornare le priorità delle regole**
Utilizza il comando [set-rule-priorities](https://docs.aws.amazon.com/cli/latest/reference/elbv2/set-rule-priorities.html).
```
aws elbv2 set-rule-priorities \
--rule-priorities "RuleArn=listener-rule-arn,Priority=5"
```
------
#### [ CloudFormation ]
**Per aggiornare le priorità delle regole**
Aggiorna la [AWS::ElasticLoadBalancingV2::ListenerRule](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-listenerrule.html)risorsa.
```
Resources:
myListenerRule:
Type: 'AWS::ElasticLoadBalancingV2::ListenerRule'
Properties:
ListenerArn: !Ref myListener
Priority: 5
Conditions:
- Field: host-header
Values:
- example.com
- www.example.com
Actions:
- Type: forward
TargetGroupArn: !Ref myTargetGroup
```
------
## Aggiorna azioni, condizioni e trasformazioni
È possibile aggiornare le azioni, le condizioni e le trasformazioni per una regola.
------
#### [ Console ]
**Per aggiornare le azioni, le condizioni e le trasformazioni delle regole**
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Selezionare **Sistemi di bilanciamento del carico** nel riquadro di navigazione.
1. Selezionare il load balancer.
1. Nella scheda **Ascoltatori e regole**, seleziona il testo nella colonna **Protocollo:Porta** per aprire la pagina dei dettagli dell'ascoltatore.
1. Nella scheda **Regole**, seleziona la regola del listener, quindi scegli **Azioni**, **Modifica** regola.
1. Aggiorna le azioni, le condizioni e le trasformazioni secondo necessità. Per informazioni dettagliate sulle fasi, consulta [Aggiungere una regola](add-rule.md).
1. Scegli **Next (Successivo)**.
1. (Facoltativo) Aggiorna la priorità.
1. Scegli **Next (Successivo)**.
1. Scegli **Save changes** (Salva modifiche).
------
#### [ AWS CLI ]
**Per aggiornare le azioni, le condizioni e le trasformazioni delle regole**
Utilizzare il comando [modify-rule](https://docs.aws.amazon.com/cli/latest/reference/elbv2/modify-rule.html). Includi almeno una delle seguenti opzioni: `--actions``--conditions`, e`--transforms`.
Per esempi di queste opzioni, vedere[Aggiungere una regola](add-rule.md).
------
#### [ CloudFormation ]
**Per aggiornare le azioni, le condizioni e le trasformazioni delle regole**
Aggiorna la [AWS::ElasticLoadBalancingV2::ListenerRule](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-listenerrule.html)risorsa.
Per le regole di esempio, consulta [Aggiungere una regola](add-rule.md).
------
## Gestisci i tag delle regole
I tag aiutano a categorizzare gli ascoltatori e le regole in modi diversi. Ad esempio, è possibile aggiungere un tag a una risorsa in base a scopo, proprietario o ambiente. Le chiavi dei tag devono essere uniche per ogni regola. Se aggiungi un tag con una chiave già associata alla regola, il valore del tag viene aggiornato.
Quando un tag non serve più, è possibile rimuoverlo.
------
#### [ Console ]
**Per gestire i tag di una regola**
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Selezionare **Sistemi di bilanciamento del carico** nel riquadro di navigazione.
1. Scegli il nome del load balancer per aprirne la pagina dei dettagli.
1. Nella scheda **Ascoltatori e regole**, seleziona il testo nella colonna **Protocollo:Porta** per aprire la pagina dei dettagli dell'ascoltatore.
1. Nella scheda **Regole**, seleziona il testo nella colonna **Name tag** per aprire la pagina di dettaglio della regola.
1. Nella pagina dei dettagli della regola, scegli **Gestisci tag**.
1. Nella pagina **Gestisci tag**, eseguire una o più delle seguenti operazioni:
1. Per aggiungere un tag, scegli **Aggiungi nuovo tag** e inserire valori per **Chiave** e **Valore**.
1. Per eliminare un tag, scegli **Rimuovi** accanto al tag.
1. Per aggiornare un tag, inserisci nuovi valori per **Chiave** o **Valore**.
1. Scegli **Save changes** (Salva modifiche).
------
#### [ AWS CLI ]
**Per aggiungere tag a una regola**
Utilizzate il comando [add-tags](https://docs.aws.amazon.com/cli/latest/reference/elbv2/add-tags.html).
```
aws elbv2 add-tags \
--resource-arns listener-rule-arn \
--tags "Key=project,Value=lima" "Key=department,Value=digital-media"
```
**Per rimuovere i tag da una regola**
Usa il comando [remove-tags](https://docs.aws.amazon.com/cli/latest/reference/elbv2/remove-tags.html).
```
aws elbv2 remove-tags \
--resource-arns listener-rule-arn \
--tag-keys project department
```
------
#### [ CloudFormation ]
**Per aggiungere tag a una regola**
Aggiorna la [AWS::ElasticLoadBalancingV2::ListenerRule](https://docs.aws.amazon.com/AWSCloudFormation/latest/TemplateReference/aws-resource-elasticloadbalancingv2-listenerrule.html)risorsa.
```
Resources:
myListenerRule:
Type: 'AWS::ElasticLoadBalancingV2::ListenerRule'
Properties:
ListenerArn: !Ref myListener
Priority: 10
Conditions:
- Field: host-header
Values:
- example.com
- www.example.com
Actions:
- Type: forward
TargetGroupArn: !Ref myTargetGroup
Tags:
- Key: 'project'
Value: 'lima'
- Key: 'department'
Value: 'digital-media'
```
------
# Eliminare una regola listener per l'Application Load Balancer
È possibile eliminare le regole non predefinite per un listener in qualsiasi momento. Non è possibile eliminare la regola predefinita per un ascoltatore. Quando si elimina un listener, vengono eliminate anche tutte le sue regole.
------
#### [ Console ]
**Come eliminare una regola**
1. Apri la console Amazon EC2 all'indirizzo [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Seleziona **Sistemi di bilanciamento del carico** nel riquadro di navigazione.
1. Selezionare il load balancer.
1. Nella scheda **Ascoltatori e regole**, seleziona il testo nella colonna **Protocollo:Porta** per aprire la pagina dei dettagli dell'ascoltatore.
1. Seleziona la regola.
1. Scegli **Actions** (Operazioni), **Delete rule** (Elimina regola).
1. Quando viene richiesta la conferma, immettere **confirm** e quindi scegliere **Elimina**.
------
#### [ AWS CLI ]
**Come eliminare una regola**
Utilizzare il comando [delete-rule](https://docs.aws.amazon.com/cli/latest/reference/elbv2/delete-rule.html).
```
aws elbv2 delete-rule \
--rule-arn listener-rule-arn
```
------