Questa pagina è stata tradotta dall'API Cloud Translation.

Risoluzione dei problemi relativi agli errori di deployment del criterio di protezione delle espressioni regolari

Stai visualizzando la documentazione di Apigee Edge.
Vai alla documentazione di Apigee X. info

InvalidRegularExpression

Messaggio di errore

Il deployment del proxy API tramite l'interfaccia utente di Edge o l'API di gestione di Edge non va a buon fine con questo messaggio di errore:

Error Deploying Revision revision_number to environment
RegularExpressionProtection policy_name: Invalid Regular Expression com.apigee.steps.regexprotection.RegularExpressionProtectionBean$RegexPattern@f4ecb23, Context Revision:revision_number;APIProxy:RegexThreat;Organization:organization;Environment:environment.

Messaggio di errore di esempio

Error Deploying Revision 1 to test
RegularExpressionProtection Regular-Expression-Protection-1: Invalid Regular Expression com.apigee.steps.regexprotection.RegularExpressionProtectionBean$RegexPattern@f4ecb23, Context Revision:1;APIProxy:RegexThreat;Organization:myorg;Environment:test.

Screenshot di errore di esempio

Testo errore Espressione regolare non valida

Causa

Se l'espressione regolare nell'elemento <Pattern> del criterio RegularExpressionProtection non è valida, il deployment dell'API Proxy non va a buon fine.

Diagnosi

Identifica il nome del criterio RegularExpressionProtection dal messaggio di errore. Ad esempio, nel seguente errore, il nome della norma RegularExpressionProtection è Regular-Expression-Protection-1:

Error Deploying Revision 1 to test
RegularExpressionProtection Regular-Expression-Protection-1: Invalid Regular Expression com.apigee.steps.regexprotection.RegularExpressionProtectionBean$RegexPattern@f4ecb23, Context Revision:1;APIProxy:RegexThreat;Organization:myorg;Environment:test.

Esamina tutti gli elementi <Pattern> nel file XML del criterio di protezione dalle espressioni regolari non riuscito. Controlla se uno degli elementi <Pattern> contiene un'espressione regolare non valida. Se uno degli elementi <Pattern> contiene un'espressione regolare non valida, è questa la causa dell'errore.

Ad esempio, il seguente criterio specifica il valore Pattern> di foo){2}, che è considerato un'espressione regolare non valida:
```
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
        <DisplayName>Regular Expression Protection-1</DisplayName>
        <Properties/>
        <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
        <URIPath>
            <Pattern>foo){2}</Pattern>
        </URIPath>
        <Source>request</Source>
    </RegularExpressionProtection>
```
Nell'esempio riportato sopra, l'espressione regolare specificata in <Pattern> manca di una parentesi di apertura. Pertanto, viene considerata come un'espressione regolare non valida. Di conseguenza, il deployment del proxy API non va a buon fine.

Risoluzione

Assicurati che ogni elemento <Pattern> nel criterio RegularExpressionProtection contenga un'espressione regolare valida. Puoi cercare diversi strumenti regex online o offline per il debug delle espressioni regolari. Per correggere il criterio di protezione delle espressioni regolari di esempio mostrato sopra, aggiungi le parentesi mancanti:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
        <DisplayName>Regular Expression Protection-1</DisplayName>
        <Properties/>
        <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
        <URIPath>
            <Pattern>(foo){2}</Pattern>
        </URIPath>
        <Source>request</Source>
    </RegularExpressionProtection>

XPathCompilationFailed

Messaggio di errore

Il deployment del proxy API tramite l'interfaccia utente di Edge o l'API di gestione di Edge non va a buon fine con questo messaggio di errore:

Error Deploying Revision revision_number to environment
RegularExpressionProtection policy_name: Failed to compile xpath xpath_expression. Context Revision:revision_number;APIProxy:RegexThreat;Organization:organization;Environment:environment.

Messaggio di errore di esempio

Error Deploying Revision 1 to test
RegularExpressionProtection Regular-Expression-Protection-1: Failed to compile xpath /notapigee:foo/notapigee:bar. Context Revision:1;APIProxy:RegexThreat;Organization:myorg;Environment:test.

Screenshot di errore di esempio

Testo dell'errore XPathCompilationFailed

Causa

Se il prefisso o il valore utilizzato nell'elemento <XPath> non fa parte di nessuno degli spazi dei nomi dichiarati nel criterio di protezione delle espressioni regolari, il deployment del proxy API non va a buon fine.

Puoi trovare ulteriori informazioni su spazi dei nomi, XPath e prefisso in Spazi dei nomi XML e come influiscono su XPath e XSLT.

Diagnosi

Identifica il nome del criterio RegularExpressionProtection in cui si è verificato l'errore e l'espressione XPath utilizzata. Puoi trovare entrambe le voci nel messaggio di errore.

Ad esempio, nell'errore seguente , il nome del criterio è Regular-Expression-Protection-1 e l'espressione XPath è /notapigee:foo/notapigee:bar:
```
Error Deploying Revision 1 to test
RegularExpressionProtection Regular-Expression-Protection-1: Failed to compile xpath /notapigee:foo/notapigee:bar. Context Revision:1;APIProxy:RegexThreat;Organization:myorg;Environment:test.
```

Nel file XML del criterio di protezione tramite espressioni regolari non riuscito, verifica che l'XPath impostato nell'elemento Expression corrisponda a quello identificato nel messaggio di errore (passaggio 1 sopra).

Ad esempio, il seguente criterio specifica l'XPath come /notapigee:foo/notapigee:bar, che corrisponde al contenuto del messaggio di errore:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
    <DisplayName>Regular Expression Protection-1</DisplayName>
    <Properties/>
    <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
    <Source>request</Source>
     <XMLPayload>
         <Namespaces>
             <Namespace prefix="apigee">http://www.apigee.com</Namespace>
         </Namespaces>
         <XPath>
             <Expression>/notapigee:foo/notapigee:bar</Expression>
             <Type>nodeset</Type>
             <Pattern>pattern</Pattern>
             <Pattern>pattern2</Pattern>
         </XPath>
     </XMLPayload>
</RegularExpressionProtection>

Esamina gli elementi <Namespaces> e <Expression> nel criterio RegularExpressionProtection. Se il <Expression> specifico indicato nel messaggio di errore utilizza un prefisso o un valore che non fa parte degli spazi dei nomi dichiarati nel criterio di protezione delle espressioni regolari, questo è il motivo dell'errore.
Tieni presente che lo specifico <XPath> utilizza il prefisso notapigee nell'esempio del criterio RegularExpressionProtection:
```
<Expression>/notapigee:foo/notapigee:bar</Expression>
```
Tuttavia, il prefisso notapigee non è definito in nessuno degli elementi <Namespace>. Di conseguenza, la compilazione di <XPath> non va a buon fine e causa un errore di deployment.

Risoluzione

Assicurati che tutti gli spazi dei nomi utilizzati negli elementi <Expression> sotto gli elementi <XPath> siano dichiarati nel criterio RegularExpressionProtection. Per correggere l'esempio riportato sopra, puoi sostituire il prefisso notapigee con apigee, che è dichiarato negli spazi dei nomi:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
    <DisplayName>Regular Expression Protection-1</DisplayName>
    <Properties/>
    <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
    <Source>request</Source>
     <XMLPayload>
         <Namespaces>
             <Namespace prefix="apigee">http://www.apigee.com</Namespace>
         </Namespaces>
         <XPath>
             <Expression>/apigee:foo/apigee:bar</Expression>
             <Type>nodeset</Type>
             <Pattern>pattern</Pattern>
             <Pattern>pattern2</Pattern>
         </XPath>
     </XMLPayload>
</RegularExpressionProtection>

CannotBeConvertedToNodeset

Messaggio di errore

Il deployment del proxy API tramite l'interfaccia utente di Edge o l'API di gestione di Edge non va a buon fine con questo messaggio di errore:

Error Deploying Revision revision_number to environment
RegularExpressionProtection policy_name: Result of xpath xpath_expression cannot be converted to nodeset. Context Revision:revision_number;APIProxy:RegexThreat;Organization:organization;Environment:environment.

Messaggio di errore di esempio

Error Deploying Revision 1 to test
RegularExpressionProtection Regular-Expression-Protection-1: Result of xpath count(//apigee:foo) cannot be converted to nodeset. Context Revision:1;APIProxy:RegexThreat;Organization:myorg;Environment:test.

Screenshot di errore di esempio

Testo dell'errore CannotBeConvertedToNodeset

Causa

Se il criterio di espressione regolare contiene un'espressione <XPath> in cui l'elemento <Type> è definito come nodeset, ma l'espressione non può essere convertita in nodeset, il deployment del proxy API non va a buon fine.

Diagnosi

Identifica il criterio RegularExpressionProtection in cui si è verificato l'errore e l'espressione XPath che non può essere convertita in nodeset. Puoi trovare entrambi questi elementi nel messaggio di errore.

Ad esempio, nell'errore seguente , il nome del criterio è Regular-Expression-Protection-1 e l'espressione XPath è count(//apigee:foo):
```
Error Deploying Revision 1 to test
RegularExpressionProtection Regular-Expression-Protection-1: Result of xpath count(//apigee:foo) cannot be converted to nodeset. Context Revision:1;APIProxy:RegexThreat;Organization:myorg;Environment:test.
```

Nel file XML del criterio di protezione tramite espressioni regolari non riuscito, verifica che l'XPath impostato nell'elemento <Expression> dell'elemento <XPath> corrisponda a quello identificato nel messaggio di errore (passaggio 1 sopra).

Ad esempio, la seguente norma specifica il valore count(//apigee:foo), che corrisponde a quello indicato nel messaggio di errore:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
        <DisplayName>Regular Expression Protection-1</DisplayName>
        <Properties/>
        <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
        <Source>request</Source>
         <XMLPayload>
             <Namespaces>
                 <Namespace prefix="apigee">http://www.apigee.com</Namespace>
             </Namespaces>
             <XPath>
                 <Expression>count(//apigee:foo)</Expression>
                 <Type>nodeset</Type>
                 <Pattern>pattern</Pattern>
                 <Pattern>pattern2</Pattern>
             </XPath>
         </XMLPayload>
    </RegularExpressionProtection>

Esamina il valore impostato nell'elemento <Type> sotto l'elemento <XPath>. Se l'elemento <Type> è nodeset, è la causa dell'errore.

In questo esempio, l'espressione XPath è count(), che non restituisce uno o più nodi. Di conseguenza, il deployment del proxy API non va a buon fine.

Risoluzione

Se l'elemento <Type> è impostato su nodeset, assicurati che il risultato dell'elemento <Expression> impostato in <XPath> sia costituito da uno o più nodi. In alternativa, modifica l'elemento <Type> con un valore più appropriato in base al tuo caso d'uso.

Per correggere l'esempio precedente, potresti modificare l'elemento <Expression> impostando un valore diverso che possa restituire nodi:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
    <DisplayName>Regular Expression Protection-1</DisplayName>
    <Properties/>
    <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
    <Source>request</Source>
     <XMLPayload>
         <Namespaces>
             <Namespace prefix="apigee">http://www.apigee.com</Namespace>
         </Namespaces>
         <XPath>
             <Expression>/apigee:foo/apigee:bar</Expression>
             <Type>nodeset</Type>
             <Pattern>pattern</Pattern>
             <Pattern>pattern2</Pattern>
         </XPath>
     </XMLPayload>
</RegularExpressionProtection>

JSONPathCompilationFailed

Messaggio di errore

Il deployment del proxy API tramite l'interfaccia utente di Edge o l'API di gestione di Edge non va a buon fine con questo messaggio di errore:

Error Deploying Revision revision_number to environment
RegularExpressionProtection policy_name: Failed to compile jsonpath jsonpath_expression Context Revision:revision_number;APIProxy:RegexThreat;Organization:organization;Environment:environment.

Messaggio di errore di esempio

Error Deploying Revision 1 to test
RegularExpressionProtection Regular-Expression-Protection-1: Failed to compile jsonpath $.store.book[*.author. Context Revision:1;APIProxy:RegexThreat;Organization:myorg;Environment:test.

Screenshot di errore di esempio

Testo dell'errore JSONPathCompilationFailed

Causa

Se l'elemento <Expression> nell'elemento <JSONPath> di un criterio di protezione delle espressioni regolari è impostato su un'espressione JSONPath non valida, il deployment del proxy API non va a buon fine.

Diagnosi

Identifica il nome del criterio RegularExpressionProtection in cui si è verificato l'errore e l'espressione JSONPath non valida utilizzata. Puoi trovare entrambi questi elementi nel messaggio di errore.

Ad esempio, nell'errore seguente , il nome del criterio è Regular-Expression-Protection-1 e l'espressione JSONPath è $.store.book[*.author:
```
Error Deploying Revision 1 to test
RegularExpressionProtection Regular-Expression-Protection-1: Failed to compile jsonpath $.store.book[*.author. Context Revision:1;APIProxy:RegexThreat;Organization:myorg;Environment:test.
```

Nel file XML del criterio di protezione tramite espressioni regolari non riuscito, verifica che il valore JSONPath impostato nell'elemento Expression corrisponda a quello identificato nel messaggio di errore (passaggio 1 sopra).

Ad esempio, il seguente criterio specifica l'elemento Expression nell'elemento <JSONPath> come $.store.book[*.author, che corrisponde al contenuto del messaggio di errore:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
        <DisplayName>Regular Expression Protection-1</DisplayName>
        <Properties/>
        <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
        <Source>request</Source>
        <JSONPayload>
             <JSONPath>
                 <Expression>$.store.book[*.author</Expression>
                 <Pattern>REGEX PATTERN</Pattern>
                 <Pattern>REGEX PATTERN</Pattern>
             </JSONPath>
            </JSONPayload>
    </RegularExpressionProtection>

Esamina l'elemento <Expression> all'interno dell'elemento <JSONPath> nel criterio. Se non corrisponde alla sintassi JSONPath, è questa la causa dell'errore. Nell'esempio precedente manca la parentesi tonda di chiusura, il che rende l'espressione non valida.

Poiché l'espressione di percorso JSON non è valida, il deployment del proxy API ha esito negativo.

Risoluzione

Assicurati che il valore dell'elemento <Expression> all'interno dell'elemento <JSONPath> nel criterio di protezione delle espressioni regolari sia un'espressione JSONPath valida.

Per correggere l'esempio mostrato sopra, puoi aggiungere la parentesi quadra di chiusura mancante al valore dell'elemento <Expression>:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
    <DisplayName>Regular Expression Protection-1</DisplayName>
    <Properties/>
    <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
    <Source>request</Source>
    <JSONPayload>
         <JSONPath>
             <Expression>$.store.book[*].author</Expression>
             <Pattern>REGEX PATTERN</Pattern>
             <Pattern>REGEX PATTERN</Pattern>
         </JSONPath>
        </JSONPayload>
</RegularExpressionProtection>

NothingToEnforce

Messaggio di errore

Il deployment del proxy API tramite l'interfaccia utente di Edge o l'API di gestione di Edge non va a buon fine con questo messaggio di errore:

Error Saving Revision revision_number
RegularExpressionProtection policy_name: at least one of URIPath, QueryParam, Header, FormParam, XMLPayload, JSONPayload is mandatory.

Messaggio di errore di esempio

Error Saving Revision 1
RegularExpressionProtection Regular-Expression-Protection-1: at least one of URIPath, QueryParam, Header, FormParam, XMLPayload, JSONPayload is mandatory.

Screenshot di errore di esempio

Testo errore NothingToEnforce

Causa

Se il criterio RegularExpressionProtection non contiene nessuno degli elementi <URIPath>, <QueryParam>, <Header>, <FormParam>, <XMLPayload> o <JSONPayload>, il deployment dell'API Proxy non va a buon fine.

Come indicato nel messaggio di errore, il criterio RegularExpressionProtection deve includere almeno uno di questi elementi: <URIPath>, <QueryParam>, <Header>, <FormParam>, <XMLPayload> o <JSONPayload>.

Diagnosi

Identifica il nome del criterio RegularExpressionProtection in cui si è verificato l'errore. Puoi trovarlo nel messaggio di errore. Ad esempio, nell'errore seguente , il nome del criterio è Regular-Expression-Protection-1:
```
RegularExpressionProtection Regular-Expression-Protection-1: at least one of URIPath, QueryParam, Header, FormParam, XMLPayload, JSONPayload is mandatory.
```
Esamina il criterio di protezione delle espressioni regolari non riuscito (identificato nel passaggio 1 qui sopra). Se il criterio non contiene nemmeno uno dei seguenti elementi: <URIPath>, <QueryParam>, <Header>, <FormParam>, <XMLPayload> o <JSONPayload>, è questa la causa dell'errore.

Ad esempio, la seguente norma di protezione tramite espressioni regolari non contiene nessuno degli elementi sopra menzionati:
```
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
        <DisplayName>Regular Expression Protection-1</DisplayName>
        <Properties/>
        <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
        <Source>request</Source>
    </RegularExpressionProtection>
```
Poiché nessuno degli elementi obbligatori è presente nel criterio Estrai variabili, il deployment del proxy API non va a buon fine.

Risoluzione

Assicurati che il criterio RegularExpressionProtection contenga almeno uno di questi elementi obbligatori: <URIPath>, <QueryParam>, <Header>, <FormParam>, <XMLPayload> o <JSONPayload>. Ad esempio:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
    <DisplayName>Regular Expression Protection-1</DisplayName>
    <Properties/>
    <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
    <Source>request</Source>
    <JSONPayload>
        <JSONPath>
            <Expression>$.store.book[*].author</Expression>
            <Pattern>REGEX PATTERN</Pattern>
            <Pattern>REGEX PATTERN</Pattern>
        </JSONPath>
    </JSONPayload>
</RegularExpressionProtection>

NoPatternsToEnforce

Messaggio di errore

Il deployment del proxy API tramite l'interfaccia utente di Edge o l'API di gestione di Edge non va a buon fine con questo messaggio di errore:

Error Saving Revision revision_number
RegularExpressionProtection policy_name: No patterns to enforce in payload_name.

Messaggio di errore di esempio

Error Saving Revision 1
RegularExpressionProtection Regular-Expression-Protection-1: No patterns to enforce in XPath.

Screenshot di errore di esempio

Testo dell'errore NoPatternsToEnforce

Causa

Se uno degli elementi di primo livello (<URIPath>, <QueryParam>, <Header>, <FormParam>, <XMLPayload> o <JSONPayload>) non ha un elemento <Pattern> definito nel criterio RegularExpressionProtection, il deployment del proxy API non va a buon fine.

Diagnosi

Identifica il nome del criterio RegularExpressionProtection in cui si è verificato l'errore e l'elemento figlio che non contiene l'elemento <Pattern>. Puoi trovare entrambi questi elementi nel messaggio di errore.

Ad esempio, nell'errore seguente, il nome del criterio è Regular-Expression-Protection-1 e l'elemento secondario è XPath:
```
RegularExpressionProtection Regular-Expression-Protection-1: No patterns to enforce in XPath.
```

Esamina il criterio di protezione delle espressioni regolari con errori e verifica se l'elemento secondario identificato nel passaggio 1 non contiene l'elemento <Pattern>. Se l'elemento <Pattern> non esiste, è la causa dell'errore.

Ad esempio, il seguente criterio non contiene l'elemento <Pattern> all'interno di <XPath>:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
      <DisplayName>Regular Expression Protection-1</DisplayName>
      <Properties/>
      <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
      <Source>request</Source>
      <XMLPayload>
        <Namespaces>
          <Namespace prefix="apigee">http://www.apigee.com</Namespace>
        </Namespaces>
        <XPath>
          <Expression>/apigee:Greeting/apigee:User</Expression>
          <Type>string</Type>
        </XPath>
      </XMLPayload>
    </RegularExpressionProtection>

Poiché l'elemento <XPath> non ha l'elemento <Pattern>, il deployment dell'API Proxy non va a buon fine.

Risoluzione

Assicurati che per uno qualsiasi degli elementi <URIPath>, <QueryParam>, <Header>, <FormParam>, <XMLPayload> o <JSONPayload> sia specificato almeno un <Pattern>. Per informazioni su come specificare correttamente l'elemento, consulta le norme relative alla protezione tramite espressioni regolari.

Per correggere l'esempio precedente, possiamo semplicemente aggiungere l'elemento <Pattern> all'elemento <XPath> sotto <XMLPayload>:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
  <DisplayName>Regular Expression Protection-1</DisplayName>
  <Properties/>
  <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
  <Source>request</Source>
  <XMLPayload>
    <Namespaces>
      <Namespace prefix="apigee">http://www.apigee.com</Namespace>
    </Namespaces>
    <XPath>
      <Expression>/apigee:Greeting/apigee:User</Expression>
      <Type>string</Type>
      <Pattern>REGEX PATTERN</Pattern>
    </XPath>
  </XMLPayload>
</RegularExpressionProtection>

NONEmptyPrefixMappedToEmptyURI

Messaggio di errore

Il deployment del proxy API tramite l'interfaccia utente di Edge o l'API di gestione di Edge non va a buon fine con questo messaggio di errore:

Error Saving Revision revision_number
RegularExpressionProtection policy_name: Non-empty prefix prefix_name cannot be mapped to empty uri.

Messaggio di errore di esempio

Error Saving Revision 1
RegularExpressionProtection Regular-Expression-Protection-1: Non-empty prefix apigee cannot be mapped to empty uri.

Screenshot di errore di esempio

Testo dell'errore NONEmptyPrefixMappedToEmptyURI

Causa

Questo errore si verifica se il criterio RegularExpressionProtection ha un prefisso definito nell'elemento <Namespace> all'interno dell'elemento <XMLPayload>, ma non è definito alcun URI.

Diagnosi

Identifica il criterio RegularExpressionProtection in cui si è verificato l'errore e il nome del prefisso non mappato all'URI. Puoi trovare entrambi questi elementi nel messaggio di errore.

Ad esempio, nel seguente errore, il nome del criterio è Protezione tramite espressioni regolari - 1 e il prefisso è apigee:
```
RegularExpressionProtection Regular-Expression-Protection-1: Non-empty prefix apigee cannot be mapped to empty uri.
```

Nel file XML del criterio di protezione tramite espressioni regolari non riuscito, verifica che il nome del prefisso impostato nell'elemento <Namespace> sotto l'elemento <XMLPayload> corrisponda al nome del prefisso identificato nel messaggio di errore (passaggio 1 sopra).

Ad esempio, il seguente criterio specifica un prefisso denominato apigee nell'elemento <Namespace> , che corrisponde a quello indicato nel messaggio di errore:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
      <DisplayName>Regular Expression Protection-1</DisplayName>
      <Properties/>
      <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
      <Source>request</Source>
      <XMLPayload>
        <Namespaces>
          <Namespace prefix="apigee"/>
          <Namespace prefix="gmail">http://mail.google.com</Namespace>
        </Namespaces>
        <XPath>
          <Expression>/apigee:Greeting/apigee:User</Expression>
          <Type>string</Type>
          <Pattern>REGEX PATTERN</Pattern>
        </XPath>
      </XMLPayload>
    </RegularExpressionProtection>

Verifica che l'elemento <Namespace> con il prefisso specifico identificato nel passaggio 2 abbia un URI valido. Se manca l'URI, questo è la causa dell'errore.

Nell'esempio di criterio di protezione delle espressioni regolari mostrato sopra, tieni presente che non esiste un URI corrispondente all'elemento <Namespace> con il prefisso apigee; pertanto, viene visualizzato l'errore:
```
Non-empty prefix apigee cannot be mapped to empty uri.
```

Risoluzione

Assicurati che tutti gli elementi <Namespace> definiti con un prefisso abbiano un URI corrispondente nel criterio Estrai variabili. Ad esempio:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
  <DisplayName>Regular Expression Protection-1</DisplayName>
  <Properties/>
  <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
  <Source>request</Source>
  <XMLPayload>
    <Namespaces>
      <Namespace prefix="apigee">http://www.apigee.com</Namespace>
      <Namespace prefix="gmail">http://mail.google.com</Namespace>
    </Namespaces>
    <XPath>
      <Expression>/apigee:Greeting/apigee:User</Expression>
      <Type>string</Type>
      <Pattern>REGEX PATTERN</Pattern>
    </XPath>
  </XMLPayload>
</RegularExpressionProtection>

DuplicatePrefix

Messaggio di errore

Il deployment del proxy API tramite l'interfaccia utente di Edge o l'API di gestione di Edge non va a buon fine con questo messaggio di errore:

Error Saving Revision revision_number
RegularExpressionProtection policy_name: Duplicate prefix prefix_name.

Messaggio di errore di esempio

Error Saving Revision 1
RegularExpressionProtection Regular-Expression-Protection-1: Duplicate prefix apigee.

Screenshot di errore di esempio

Testo dell'errore di prefisso duplicato

Causa

Questo errore si verifica se il criterio di protezione delle espressioni regolari ha lo stesso prefisso definito più volte nell'elemento <Namespace> all'interno dell'elemento <XMLPayload>.

Ad esempio, questo errore si verifica perché il prefisso apigee è definito due volte come mostrato di seguito:

<Namespace prefix="apigee">http://www.apigee.com</Namespace>
<Namespace prefix="apigee">http://www.apigee.com</Namespace>

Diagnosi

Identifica il criterio RegularExpressionProtection in cui si è verificato l'errore e il nome del prefisso. Puoi trovare entrambi questi elementi nel messaggio di errore.

Ad esempio, nel seguente errore, il nome del criterio è Protezione tramite espressioni regolari - 1 e il prefisso è apigee:
```
RegularExpressionProtection Regular-Expression-Protection-1: Duplicate prefix apigee.
```

Ad esempio, il seguente criterio specifica un prefisso denominato apigee nell'elemento <Namespace> , che corrisponde a quello indicato nel messaggio di errore:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
      <DisplayName>Regular Expression Protection-1</DisplayName>
      <Properties/>
      <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
      <Source>request</Source>
      <XMLPayload>
        <Namespaces>
          <Namespace prefix="apigee">http://www.apigee.com</Namespace>
          <Namespace prefix="apigee">http://www.apigee.com</Namespace>
        </Namespaces>
        <XPath>
          <Expression>/apigee:Greeting/apigee:User</Expression>
          <Type>string</Type>
          <Pattern>REGEX PATTERN</Pattern>
        </XPath>
      </XMLPayload>
    </RegularExpressionProtection>

Determina se l'elemento <Namespace> con il prefisso specifico identificato nel passaggio 2 è stato definito più volte. Se viene definito più di una volta, ciò è la causa dell'errore.

Nel criterio di protezione delle espressioni regolari di esempio mostrato sopra, nota che l'elemento <Namespace> con il prefisso apigee è stato definito due volte; pertanto, si verifica l'errore:
```
Duplicate prefix apigee.
```

Risoluzione

Assicurati che esista una sola definizione per ogni prefisso negli elementi <Namespace> del criterio RegularExpressionProtection. Ad esempio:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
      <DisplayName>Regular Expression Protection-1</DisplayName>
      <Properties/>
      <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
      <Source>request</Source>
      <XMLPayload>
        <Namespaces>
          <Namespace prefix="apigee">http://www.apigee.com</Namespace>
        </Namespaces>
        <XPath>
          <Expression>/apigee:Greeting/apigee:User</Expression>
          <Type>string</Type>
          <Pattern>REGEX PATTERN</Pattern>
        </XPath>
      </XMLPayload>
    </RegularExpressionProtection>

EmptyXPathExpression

Messaggio di errore

Il deployment del proxy API tramite l'interfaccia utente di Edge o l'API di gestione di Edge non va a buon fine con questo messaggio di errore:

Error Saving Revision revision_number
RegularExpressionProtection policy_name: Empty XPath expression.

Messaggio di errore di esempio

Error Saving Revision 1
RegularExpressionProtection Regular-Expression-Protection-1: Empty XPath expression.

Screenshot di errore di esempio

Testo dell'errore EmptyXPathExpression

Causa

Se il criterio RegularExpressionProtection non ha un elemento <Expression> impostato all'interno dell'elemento <XPath>, il deployment del proxy API non va a buon fine.

Diagnosi

Identifica il criterio di protezione delle espressioni regolari non riuscito dal messaggio di errore. Ad esempio, nel seguente errore, il nome del criterio è Protezione-per-espressioni-regolari-1:
```
RegularExpressionProtection Regular-Expression-Protection-1: Empty XPath expression.
```

Nel file XML del criterio di protezione delle espressioni regolari non riuscito, determina se è presente un elemento <XMLPayload> con un elemento secondario <XPath> che non contiene un elemento <Expression> definito o se l'elemento <Expression> non è impostato su nessun valore. In questo caso, è la causa dell'errore.

Ad esempio, di seguito è riportato un criterio di protezione delle espressioni regolari con un elemento <XMLPayload>:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
  <DisplayName>Regular Expression Protection-1</DisplayName>
  <Properties/>
  <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
  <Source>request</Source>
  <XMLPayload>
    <Namespaces>
      <Namespace prefix="apigee">http://www.apigee.com</Namespace>
    </Namespaces>
    <XPath>
      <Expression></Expression>
      <Type>string</Type>
      <Pattern>REGEX PATTERN</Pattern>
    </XPath>
  </XMLPayload>
</RegularExpressionProtection>

Poiché all'interno dell'elemento <XPath> è presente un elemento <Expression> vuoto, il deployment dell'API Proxy non va a buon fine.

Risoluzione

Assicurati che il criterio RegularExpressionProtection abbia un elemento <Expression> non vuoto e valido definito nell'elemento <XPath>. Ad esempio:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
  <DisplayName>Regular Expression Protection-1</DisplayName>
  <Properties/>
  <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
  <Source>request</Source>
  <XMLPayload>
    <Namespaces>
      <Namespace prefix="apigee">http://www.apigee.com</Namespace>
    </Namespaces>
    <XPath>
      <Expression>/apigee:Greeting/apigee:User</Expression>
      <Type>string</Type>
      <Pattern>REGEX PATTERN</Pattern>
    </XPath>
  </XMLPayload>
</RegularExpressionProtection>

EmptyJSONPathExpression

Messaggio di errore

Il deployment del proxy API tramite l'interfaccia utente di Edge o l'API di gestione di Edge non va a buon fine con questo messaggio di errore:

Error Saving Revision revision_number
RegularExpressionProtection policy_name: Empty JSONPath expression.

Messaggio di errore di esempio

Error Saving Revision 1
RegularExpressionProtection Regular-Expression-Protection-1: Empty JSONPath expression.

Screenshot di errore di esempio

Testo dell'errore EmptyJSONPathExpression

Causa

Se per il criterio RegularExpressionProtection non è impostato alcun elemento <Expression> all'interno dell'elemento <JSONPath>, il deployment del proxy API non va a buon fine.

Diagnosi

Identifica il criterio di protezione delle espressioni regolari non riuscito dal messaggio di errore. Ad esempio, nel seguente errore, il nome del criterio è Protezione-per-espressioni-regolari-1:
```
Error Saving Revision 1
RegularExpressionProtection Regular-Expression-Protection-1: Empty JSONPath expression.
```

Nel file XML dei criteri di protezione delle espressioni regolari non riusciti, determina se è presente un elemento <JSONPayload> con un elemento secondario <JSONPath> che non contiene un elemento <Expression> definito o se l'elemento <Expression> non è impostato su nessun valore. In questo caso, è la causa dell'errore.

Ad esempio, di seguito è riportato un criterio di protezione delle espressioni regolari con un elemento <JSONPayload>:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
      <DisplayName>Regular Expression Protection-1</DisplayName>
      <Properties/>
      <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
      <Source>request</Source>
      <JSONPayload>
        <JSONPath>
          <Expression></Expression>
          <Pattern>REGEX PATTERN</Pattern>
          <Pattern>REGEX PATTERN</Pattern>
        </JSONPath>
      </JSONPayload>
    </RegularExpressionProtection>

Poiché all'interno dell'elemento <JSONPath> è presente un elemento <Expression> vuoto, il deployment dell'API Proxy non va a buon fine.

Risoluzione

Assicurati che il criterio RegularExpressionProtection abbia un elemento <Expression> non vuoto e valido definito sotto l'elemento <JSONPath>. Ad esempio:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<RegularExpressionProtection async="false" continueOnError="false" enabled="true" name="Regular-Expression-Protection-1">
  <DisplayName>Regular Expression Protection-1</DisplayName>
  <Properties/>
  <IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
  <Source>request</Source>
  <JSONPayload>
    <JSONPath>
      <Expression>$.store.book[*].author</Expression>
      <Pattern>REGEX PATTERN</Pattern>
      <Pattern>REGEX PATTERN</Pattern>
    </JSONPath>
  </JSONPayload>
</RegularExpressionProtection>