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à.

# Updating/migrating a Envoy 1.17
<a name="1.17-migration"></a>

**Importante**  
Avviso di fine del supporto: il 30 settembre 2026, AWS interromperà il supporto per. AWS App Mesh Dopo il 30 settembre 2026, non potrai più accedere alla AWS App Mesh console o alle risorse. AWS App Mesh Per ulteriori informazioni, consulta questo post di blog [Migrazione AWS App Mesh da Amazon ECS Service Connect.](https://aws.amazon.com/blogs/containers/migrating-from-aws-app-mesh-to-amazon-ecs-service-connect) 

## Secret Discovery Service con SPIRE
<a name="spire-update"></a>

Se utilizzi SPIRE (SPIFFE Runtime Environment) con App Mesh per distribuire certificati di fiducia ai tuoi servizi, verifica di utilizzare almeno la versione `0.12.0` dell'[agente SPIRE](https://github.com/spiffe/spire/releases/tag/v0.12.0) (rilasciata a dicembre 2020). Questa è la prima versione che può supportare le versioni di Envoy successive. `1.16`

## Modifiche alle espressioni regolari
<a name="regular-expressions"></a>

A partire da Envoy`1.17`, App Mesh configura Envoy per utilizzare il motore di espressioni regolari [RE2](https://github.com/google/re2) per impostazione predefinita. Questa modifica è evidente alla maggior parte degli utenti, ma le corrispondenze in Routes o Gateway Routes non consentono più riferimenti in avanti o indietro nelle espressioni regolari.

### Aspetto prospettico positivo e negativo
<a name="positive-look-ahead"></a>

**Positivo:** una prospettiva positiva è un'espressione tra parentesi che inizia con: `?=`

```
(?=example)
```

Queste sono le più utili quando si effettua la sostituzione di stringhe perché consentono di abbinare una stringa senza consumare i caratteri come parte della corrispondenza. Poiché App Mesh non supporta la sostituzione di stringhe regex, ti consigliamo di sostituirle con corrispondenze regolari.

```
(example)
```

**Negativo:** una previsione negativa è un'espressione tra parentesi che inizia con. `?!`

```
ex(?!amp)le
```

Le espressioni tra parentesi vengono utilizzate per affermare che una parte dell'espressione non corrisponde a un determinato input. Nella maggior parte dei casi, è possibile sostituirle con un quantificatore zero.

```
ex(amp){0}le
```

Se l'espressione stessa è una classe di caratteri, potete negare l'intera classe e contrassegnarla come facoltativa utilizzando. `?`

```
prefix(?![0-9])suffix => prefix[^0-9]?suffix
```

A seconda del caso d'uso, potresti anche essere in grado di modificare i percorsi per gestirlo.

```
{
    "routeSpec": {
        "priority": 0,
        "httpRoute": {
            "match": {
                "headers": [
                    {
                        "name": "x-my-example-header",
                        "match": {
                            "regex": "^prefix(?!suffix)"
                        }
                    }
                ]
            }
        }
    }
}

{
    "routeSpec": {
        "priority": 1,
        "httpRoute": {
            "match": {
                "headers": [
                    {
                        "name": "x-my-example-header",
                        "match": {
                            "regex": "^prefix"
                        }
                    }
                ]
            }
        }
    }
}
```

La prima corrispondenza del percorso cerca un'intestazione che inizia con «prefisso» ma non seguita da «suffisso». La seconda route fa in modo che corrisponda a tutte le altre intestazioni che iniziano con «prefisso», incluse quelle che terminano con «suffisso». Invece, possono anche essere invertiti per rimuovere il look-ahead negativo.

```
{
    "routeSpec": {
        "priority": 0,
        "httpRoute": {
            "match": {
                "headers": [
                    {
                        "name": "x-my-example-header",
                        "match": {
                            "regex": "^prefix.*?suffix"
                        }
                    }
                ]
            }
        }
    }
}

{
    "routeSpec": {
        "priority": 1,
        "httpRoute": {
            "match": {
                "headers": [
                    {
                        "name": "x-my-example-header",
                        "match": {
                            "regex": "^prefix"
                        }
                    }
                ]
            }
        }
    }
}
```

Questo esempio inverte le rotte per dare maggiore priorità alle intestazioni che terminano con «suffix» e tutte le altre intestazioni che iniziano con «prefix» vengono abbinate alla route con priorità più bassa.

## Riferimenti all'indietro
<a name="back-references"></a>

Un riferimento a ritroso è un modo per scrivere espressioni più brevi ripetendole in un precedente gruppo tra parentesi. Hanno questa forma.

```
(group1)(group2)\1
```

Una barra rovesciata `\` seguita da un numero funge da segnaposto per l'ennesimo gruppo tra parentesi nell'espressione. In questo esempio, `\1` viene utilizzato come metodo alternativo per scrivere una seconda volta. `(group1)`

```
(group1)(group2)(group1)
```

Questi possono essere rimossi semplicemente sostituendo il riferimento all'indietro con il gruppo a cui si fa riferimento, come nell'esempio.