Questa pagina è stata tradotta dall'API Cloud Translation.

Sintassi delle query di ricerca

Quando cerchi asset, puoi filtrare i risultati di ricerca specificando una query composta da un campo dei metadati dell'asset, un operatore e un valore.

Campi e risorse ricercabili

Per i campi che puoi utilizzare in una query searchAllResources, consulta Campi ResourceSearchResult.

Per i campi che puoi utilizzare in una query searchAllIamPolicies, vedi Campi IamPolicySearchResult.

Per le risorse che puoi cercare, consulta Tipi di risorse.

Corrispondenza del testo

Quando cerchi una corrispondenza di testo, puoi trovare una corrispondenza esatta o parziale di un campo dei metadati dell'asset.

Corrispondenza esatta del testo

Per una corrispondenza esatta del testo, utilizza l'operatore = (uguale) con la seguente sintassi:

ASSET_METADATA_FIELD=QUERY

Ad esempio:

location=us-central1-a

Tieni presente le seguenti regole quando esegui una corrispondenza esatta del testo:

Affinché la query sia vera, il valore della query deve corrispondere esattamente al valore del campo dei metadati della risorsa.
Per un campo con un valore di elenco, se il valore della query corrisponde a uno degli elementi dell'elenco, viene considerata una corrispondenza.
I valori delle query sono sensibili alle maiuscole.
Un valore di query a corrispondenza esatta viene trattato come una frase, ma non può contenere caratteri jolly.

Corrispondenza parziale del testo

Per una corrispondenza parziale del testo, utilizza l'operatore : (contiene) con la seguente sintassi:

ASSET_METADATA_FIELD:QUERY

Ad esempio:

location:us-central1

Quando esegui una ricerca con l'operatore :, i valori della query e i valori dei campi dei metadati degli asset vengono convertiti in token per il confronto. Ogni parola del valore della query viene controllata per verificare se esiste in ordine consecutivo nel valore del campo dei metadati dell'asset. Quando utilizzi corrispondenze parziali, i valori della query non distinguono tra maiuscole e minuscole.

I valori delle query di corrispondenza parziale possono essere frasi o una combinazione di frasi e possono contenere caratteri jolly. In una query è possibile effettuare fino a 10 confronti, con un massimo di 2048 caratteri. Se hai un caso d'uso per query più lunghe, contatta gcp-asset-inventory-and-search-feedback@googlegroups.com.

Regole di tokenizzazione

Le regole di tokenizzazione per la corrispondenza parziale del testo sono le seguenti:

I caratteri speciali iniziali e finali vengono rimossi.
I caratteri non alfanumerici ([a-zA-Z0-9]), i trattini bassi (_) o le e commerciali (&) vengono trattati come delimitatori.

Ecco alcuni esempi di tokenizzazione:

us-central1 è tokenizzato in [us,central1]
alex-2020@EXAMPLE.com è tokenizzato in [alex,2020,example,com]
google.com/cloud è tokenizzato in [google,com,cloud]
Compute %Instance% è tokenizzato in [compute,instance]
$%^*-! è tokenizzato in []
compute*storage è tokenizzato in [compute,storage]
compute&storage è tokenizzato in [compute&storage]
ALEX_test@example.com è tokenizzato in [alex_test,example,com]
instance/_my_vm_ è tokenizzato in [instance,_my_vm_]

Esempi di corrispondenza esatta e parziale del testo

Una risorsa il cui campo location ha il valore us-central1-a corrisponde alle seguenti query.

Query	Motivo della corrispondenza
location=us-central1-a	Corrisponde perché la frase `us-central1-a` è esattamente uguale al valore del campo.
location:US-Central1-A	Corrispondenza perché i caratteri di punteggiatura vengono trattati come delimitatori e il valore della query non fa distinzione tra maiuscole e minuscole.
location:"us central1 a"	Corrispondenza perché le parole nella frase `"us central1 a"` corrispondono al valore del campo in ordine consecutivo.
location:(central1 us a)	Corrisponde perché le parole nella combinazione `(central1 us a)` corrispondono alle parole nel valore del campo in qualsiasi ordine.
location:(a "us central1")	Corrisponde perché le frasi all'interno della combinazione, `a` e `"us central1"`, corrispondono alle parole nel valore del campo in qualsiasi ordine. Poiché `"us central1"` è una frase, queste parole devono corrispondere in ordine consecutivo.
location:us-central*	Corrispondenza perché il carattere jolly `*` viene utilizzato per creare una corrispondenza con il prefisso.

Una risorsa il cui campo location ha valore us-central1-a non corrisponde alle seguenti query.

Query	Motivo della mancata corrispondenza
location=US-central1-a	Non corrisponde perché la frase è sensibile alle maiuscole. Utilizza invece l'operatore `:` per le corrispondenze senza distinzione tra maiuscole e minuscole.
location=us-central1	Non corrisponde perché la frase corrisponde parzialmente al valore del campo. Utilizza invece l'operatore `:` per le corrispondenze parziali.

Costruire una query di corrispondenza esatta

Un valore di query può essere costituito da frasi, combinazioni, negazioni e caratteri jolly.

Frasi

Una frase è una o più parole che vengono abbinate in ordine. Per trovare corrispondenze con le parole senza rispettare l'ordine, utilizza le combinazioni.

La seguente query corrisponde alle risorse il cui campo policy contiene la parola alex e la parola 2020 in ordine consecutivo:

policy:"alex 2020"

Un asset il cui valore del campo policy è "alex.2020@example.com" corrisponde alla query, perché le parole alex e 2020 sono in ordine consecutivo. Il . viene ignorato perché la punteggiatura viene trattata come delimitatore.

Un asset il cui valore del campo policy è "2020.alex@example.com" o "alex.us.2020@example.com" non corrisponde, perché le parole alex e 2020 non sono in ordine consecutivo.

Costruire una frase

Quando crei una frase, tieni presente le seguenti regole:

Se la frase contiene solo caratteri dell'alfabeto latino di base ISO [a-zA-Z], numeri [0-9], connettori di base per email o URL [_-+.@/&] o caratteri jolly [*], non è necessario racchiuderla tra virgolette doppie:
```
policy:alex.2020@example.com
```
Tuttavia, il wrapping tra virgolette doppie funziona ancora e si comporta allo stesso modo:
```
policy:"alex.2020@example.com"
```
Se la frase contiene spazi o altri caratteri speciali, deve essere racchiusa tra doppi apici:
```
location:"us central1"
```
Se la frase è racchiusa tra virgolette doppie e contiene anche virgolette doppie (") o una barra rovesciata (\), devi eseguirne l'escape come \" o \\. In alternativa, sostituiscili con un singolo spazio, poiché i caratteri non alfanumerici vengono trattati come delimitatori durante l'esecuzione di una ricerca. Le seguenti query vengono trattate allo stesso modo:
```
description:"One of \"those\" descriptions."
description:"One of those descriptions."
```
Quando utilizzi gcloud CLI o l'API REST, devi eseguire l'escape delle virgolette doppie utilizzate per indicare una frase:
```
--query="location:(a \"us central1\")"
```
```
"query": "location:(a \"us central1\")"
```

Combinazioni

Le frasi di ricerca possono essere combinate utilizzando gli operatori logici in maiuscolo AND o OR. L'inclusione di AND è facoltativa quando utilizzi le parentesi. Ad esempio, le seguenti query vengono trattate allo stesso modo:

policy:(alex charlie)
policy:(alex AND charlie)

Se una risorsa contiene un campo metadati con un elenco di valori, una combinazione AND non garantisce che tutte le parole debbano trovarsi in un singolo elemento. Ad esempio, se un campo dei metadati è policy=["alex@example.com", "bola@example.com", "charlie@example.com"], la ricerca con policy:(alex charlie) corrisponde, perché alex@example.com contiene alex e charlie@example.com contiene charlie.

Puoi utilizzare le parentesi per raggruppare i tipi di combinazione. Il seguente esempio restituisce gli asset che hanno un campo relativo alle norme che contiene alex e charlie in qualsiasi ordine oppure gli asset che hanno un campo relativo alle norme che contiene bola.

policy:((alex charlie) OR bola)

Puoi utilizzare una frase all'interno di una combinazione per trovare più parole in ordine consecutivo. L'esempio seguente restituisce gli asset che hanno un campo policy che contiene alex e 2020 in ordine consecutivo oppure bola:

policy:(("alex 2020") OR bola)

Esempi di combinazioni

Le seguenti query mostrano varie combinazioni. Prendi nota del posizionamento delle parentesi per separare gli operatori AND e OR. La combinazione di operatori all'interno di un unico insieme di parentesi non è valida. Ad esempio: policy:(alex charlie OR bola).

Query	Descrizione
policy:(alex charlie)	Restituisce gli asset il cui campo `policy` contiene sia `alex` sia `charlie`.
policy:(alex OR charlie)	Restituisce gli asset il cui campo `policy` contiene `alex` o `charlie`.
policy:((alex charlie) OR bola)	Restituisce gli asset il cui campo `policy` contiene sia `alex` sia `charlie` oppure la parola `bola`.
policy:(alex charlie) OR name:bola	Restituisce gli asset il cui campo `policy` contiene `alex` e `charlie` o il cui campo `name` contiene `bola`.

Negazione

Le query di ricerca possono essere negate utilizzando l'operatore NOT in maiuscolo. Le parentesi sono supportate, ma non obbligatorie.

Esempi di negazione

Restituisce gli asset il cui campo state non contiene la parola running.
```
NOT state:running
```
Restituisce gli asset il cui campo policy non contiene né alex né charlie.
```
NOT policy:(alex OR charlie)
```
Restituisci gli asset il cui campo networkTags non contiene internal o private.
```
NOT (networkTags:internal OR networkTags:private)
```

Caratteri jolly

Gli asterischi (*) possono essere utilizzati in una frase come carattere jolly. A seconda della posizione, un asterisco può avere significati diversi.

Se * si trova alla fine di una frase, viene trattato come una corrispondenza di prefisso del token. Ad esempio, "al 20*" è equivalente a (al* 20*). L'ordine dei prefissi non è importante.

La frase "al 20*" corrisponde a un valore del campo con un token che inizia con al (ad esempio alex) e un token che inizia con 20 (ad esempio 2020).
Per labels, se l'intero valore della query contiene un solo *, ad esempio "labels.env:*", rappresenta un controllo di esistenza. ovvero Cloud Asset Inventory verifica l'esistenza della chiave dell'etichetta env. Solo il campo labels supporta i controlli di esistenza.
Se * si trova al centro di una frase, ad esempio "compute*storage", viene trattato come un delimitatore di tokenizzazione. Questo valore della query equivale a "compute storage".
Se * si trova sia all'inizio che alla fine di una frase, ad esempio "*compute storage*", viene trattato come delimitatore di tokenizzazione. Questo valore della query equivale a "compute storage".

Confronto numerico e dei timestamp

Per il confronto numerico e dei timestamp, utilizza gli operatori di confronto con la seguente sintassi:

ASSET_METADATA_FIELD>=QUERY

Gli operatori di confronto disponibili sono i seguenti:

=: uguale a
>: maggiore di
>=: maggiore o uguale a
<: minore di
<=: minore o uguale a

Per eseguire un confronto con timestamp come quelli archiviati nei campi dei metadati degli asset createTime e updateTime, utilizza un numero intero con segno a 64 bit (il timestamp epoch in secondi) o una stringa data/ora UTC+0 in uno dei seguenti formati:

2021-01-01 (AAAA-MM-GG)
"2021-01-01T00:00:00" ("YYYY-MM-DDThh:mm:ss")

Esempi di data/ora

Una risorsa il cui campo createTime ha valore 1609459200 (timestamp Unix di 2021-01-01T00:00:00) corrisponde alle seguenti query:

createTime=1609459200
createTime=2021-01-01
createTime="2021-01-01T00:00:00"

createTime>1500000000
createTime>2020-01-01
createTime>"2020-01-01T00:00:00"

createTime>=1609459200
createTime>=2021-01-01
createTime>="2021-01-01T00:00:00"

createTime<1700000000
createTime<2022-01-01
createTime<"2022-01-01T00:00:00"

createTime<=1609459200
createTime<=2021-01-01
createTime<="2021-01-01T00:00:00"