Scrittura di classificatori personalizzati grok Scrittura di classificatori XML personalizzati Scrittura di JSON classificatori personalizzati Scrittura di classificatori CSV personalizzati

Scrittura di classificatori personalizzati per diversi formati di dati

Puoi fornire un classificatore personalizzato per classificare i dati in AWS Glue. È possibile creare un classificatore personalizzato utilizzando un pattern grok, un XML tag, JavaScript Object Notation (JSON) o valori separati da virgole (). CSV Un crawler AWS Glue richiama un classificatore personalizzato. Se il classificatore riconosce i dati, esso restituisce la classificazione e lo schema dei dati al crawler. Potrebbe essere necessario definire un classificatore personalizzato nel caso in cui i dati non corrispondano ad alcun classificatore integrato, oppure se si intende personalizzare le tabelle create dal crawler.

Per ulteriori informazioni sulla creazione di un classificatore tramite la console AWS Glue, consulta Creazione di classificatori utilizzando la console AWS Glue.

AWS Glue esegue i classificatori personalizzati prima dei classificatori predefiniti, in base all'ordine da te specificato. Quando un crawler individua un classificatore corrispondente ai dati, lo schema e la stringa di classificazione vengono usati nella definizione delle tabelle che vengono scritte nel AWS Glue Data Catalog.

Argomenti

Scrittura di classificatori personalizzati grok
Scrittura di classificatori XML personalizzati
Scrittura di JSON classificatori personalizzati
Scrittura di classificatori CSV personalizzati

Scrittura di classificatori personalizzati grok

Grok è uno strumento che consente di analizzare dati testuali dato un pattern corrispondente. Un pattern grok è un set denominato di espressioni regolari (regex) che vengono usate per confrontare i dati di una riga per volta. AWS Glue usa pattern grok dedurre lo schema dei dati. Quando un pattern grok individua la corrispondenza dei dati, AWS Glue usa il pattern per determinare la struttura dei dati e mapparla in campi.

AWS Glue offre numerosi pattern predefiniti, ma puoi definirne di personalizzati. È possibile creare un pattern grok tramite pattern integrati o pattern personalizzati nella definizione di classificatori personalizzati. È possibile adattare un pattern grok per classificare i formati di file di testo personalizzati.

Nota

I classificatori personalizzati grok AWS Glue usano la libreria di serializzazione GrokSerDe per le tabelle create nel AWS Glue Data Catalog. Se utilizzi Amazon Athena, Amazon o Redshift SpectrumEMR, consulta la documentazione relativa a tali servizi per informazioni sul supporto di. AWS Glue Data Catalog GrokSerDe Al momento, potresti riscontrare problemi durante l'interrogazione di tabelle create con Amazon EMR e Redshift Spectrum. GrokSerDe

Di seguito è riportata la sintassi di base per i componenti di un pattern grok:


%{PATTERN:field-name}

I dati corrispondenti al PATTERN denominato vengono mappati alla colonna field-name nello schema, con un tipo di string di dati predefinito. Facoltativamente, è possibile eseguire il cast del tipo di dati per il campo in byte, boolean, double, short, int, long o float nello schema risultante.


%{PATTERN:field-name:data-type}

Ad esempio, per trasmettere un campo num a un tipo di dati int, si può utilizzare questo pattern:


%{NUMBER:num:int}

I pattern possono essere costituiti da altri pattern. Ad esempio, può esserci un pattern per un timestamp SYSLOG definito da pattern per mese, giorno del mese e ora (ad esempio, Feb 1 06:25:43). Per questi dati, è possibile definire il pattern seguente:


SYSLOGTIMESTAMP %{MONTH} +%{MONTHDAY} %{TIME}

Nota

I pattern grok sono in grado di elaborare una sola riga alla volta. I pattern a righe multiple non sono supportati. In aggiunta, le interruzioni di riga all'interno dei pattern non sono supportate.

Valori personalizzati per il classificatore grok

Quando si definisce un classificatore grok, si forniscono i seguenti valori per creare il classificatore personalizzato.

Nome

Nome del classificatore.

Classificazione

La stringa di testo scritta per descrivere il formato dei dati da classificare, ad esempio special-logs.

Pattern grok

Il set di pattern applicati al datastore per determinare l'esistenza di corrispondenze. Questi pattern provengono dai AWS Gluepattern predefiniti di e da eventuali pattern personalizzati da te definiti.

Di seguito è riportato un esempio di pattern grok:


%{TIMESTAMP_ISO8601:timestamp} \[%{MESSAGEPREFIX:message_prefix}\] %{CRAWLERLOGLEVEL:loglevel} : %{GREEDYDATA:message}

Quando i dati corrispondono a TIMESTAMP_ISO8601, viene creata una colonna di schema timestamp. Il funzionamento è analogo per i restanti pattern denominati nell'esempio.

Pattern personalizzati

Pattern personalizzati facoltativi da te definiti. Il pattern grok che classifica i dati fa riferimento a questi pattern. È possibile fare riferimento a questi pattern personalizzati nel pattern grok applicato ai dati. Ciascun pattern personalizzato che compone il pattern grok deve trovarsi su righe separate. Per definire il pattern, si utilizza la sintassi Espressione regolare (regex).

Di seguito è riportato un esempio di utilizzo di pattern personalizzati:


CRAWLERLOGLEVEL (BENCHMARK|ERROR|WARN|INFO|TRACE)
MESSAGEPREFIX .*-.*-.*-.*-.*

Il primo pattern personalizzato denominato, CRAWLERLOGLEVEL, costituisce una corrispondenza quando i dati corrispondono a una delle stringhe enumerate. Il secondo pattern personalizzato, MESSAGEPREFIX, tenta di abbinare una stringa di messaggio di prefisso.

AWS Glue tiene traccia della data e dell'ora di creazione, della data e dell'ora dell'ultimo aggiornamento e della versione del classificatore.

Schemi incorporati

AWS Glue offre molti pattern comuni che puoi usare per creare un classificatore personalizzato. É possibile aggiungere un pattern denominato al grok pattern all'interno di una definizione di classificatore.

L'elenco seguente comprende una riga per ciascun pattern. In ciascuna riga, il nome del pattern è seguito dalla sua definizione. Per definire il pattern, viene usata la sintassi delle espressioni regolari (regex).


#<noloc>&GLU;</noloc> Built-in patterns
 USERNAME [a-zA-Z0-9._-]+
 USER %{USERNAME:UNWANTED}
 INT (?:[+-]?(?:[0-9]+))
 BASE10NUM (?<![0-9.+-])(?>[+-]?(?:(?:[0-9]+(?:\.[0-9]+)?)|(?:\.[0-9]+)))
 NUMBER (?:%{BASE10NUM:UNWANTED})
 BASE16NUM (?<![0-9A-Fa-f])(?:[+-]?(?:0x)?(?:[0-9A-Fa-f]+))
 BASE16FLOAT \b(?<![0-9A-Fa-f.])(?:[+-]?(?:0x)?(?:(?:[0-9A-Fa-f]+(?:\.[0-9A-Fa-f]*)?)|(?:\.[0-9A-Fa-f]+)))\b
 BOOLEAN (?i)(true|false)
 
 POSINT \b(?:[1-9][0-9]*)\b
 NONNEGINT \b(?:[0-9]+)\b
 WORD \b\w+\b
 NOTSPACE \S+
 SPACE \s*
 DATA .*?
 GREEDYDATA .*
 #QUOTEDSTRING (?:(?<!\\)(?:"(?:\\.|[^\\"])*"|(?:'(?:\\.|[^\\'])*')|(?:`(?:\\.|[^\\`])*`)))
 QUOTEDSTRING (?>(?<!\\)(?>"(?>\\.|[^\\"]+)+"|""|(?>'(?>\\.|[^\\']+)+')|''|(?>`(?>\\.|[^\\`]+)+`)|``))
 UUID [A-Fa-f0-9]{8}-(?:[A-Fa-f0-9]{4}-){3}[A-Fa-f0-9]{12}
 
 # Networking
 MAC (?:%{CISCOMAC:UNWANTED}|%{WINDOWSMAC:UNWANTED}|%{COMMONMAC:UNWANTED})
 CISCOMAC (?:(?:[A-Fa-f0-9]{4}\.){2}[A-Fa-f0-9]{4})
 WINDOWSMAC (?:(?:[A-Fa-f0-9]{2}-){5}[A-Fa-f0-9]{2})
 COMMONMAC (?:(?:[A-Fa-f0-9]{2}:){5}[A-Fa-f0-9]{2})
 IPV6 ((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(%.+)?
 IPV4 (?<![0-9])(?:(?:25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2})[.](?:25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2})[.](?:25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2})[.](?:25[0-5]|2[0-4][0-9]|[0-1]?[0-9]{1,2}))(?![0-9])
 IP (?:%{IPV6:UNWANTED}|%{IPV4:UNWANTED})
 HOSTNAME \b(?:[0-9A-Za-z][0-9A-Za-z-_]{0,62})(?:\.(?:[0-9A-Za-z][0-9A-Za-z-_]{0,62}))*(\.?|\b)
 HOST %{HOSTNAME:UNWANTED}
 IPORHOST (?:%{HOSTNAME:UNWANTED}|%{IP:UNWANTED})
 HOSTPORT (?:%{IPORHOST}:%{POSINT:PORT})
 
 # paths
 PATH (?:%{UNIXPATH}|%{WINPATH})
 UNIXPATH (?>/(?>[\w_%!$@:.,~-]+|\\.)*)+
 #UNIXPATH (?<![\w\/])(?:/[^\/\s?*]*)+
 TTY (?:/dev/(pts|tty([pq])?)(\w+)?/?(?:[0-9]+))
 WINPATH (?>[A-Za-z]+:|\\)(?:\\[^\\?*]*)+
 URIPROTO [A-Za-z]+(\+[A-Za-z+]+)?
 URIHOST %{IPORHOST}(?::%{POSINT:port})?
 # uripath comes loosely from RFC1738, but mostly from what Firefox
 # doesn't turn into %XX
 URIPATH (?:/[A-Za-z0-9$.+!*'(){},~:;=@#%_\-]*)+
 #URIPARAM \?(?:[A-Za-z0-9]+(?:=(?:[^&]*))?(?:&(?:[A-Za-z0-9]+(?:=(?:[^&]*))?)?)*)?
 URIPARAM \?[A-Za-z0-9$.+!*'|(){},~@#%&/=:;_?\-\[\]]*
 URIPATHPARAM %{URIPATH}(?:%{URIPARAM})?
 URI %{URIPROTO}://(?:%{USER}(?::[^@]*)?@)?(?:%{URIHOST})?(?:%{URIPATHPARAM})?
 
 # Months: January, Feb, 3, 03, 12, December
 MONTH \b(?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:tember)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)\b
 MONTHNUM (?:0?[1-9]|1[0-2])
 MONTHNUM2 (?:0[1-9]|1[0-2])
 MONTHDAY (?:(?:0[1-9])|(?:[12][0-9])|(?:3[01])|[1-9])
 
 # Days: Monday, Tue, Thu, etc...
 DAY (?:Mon(?:day)?|Tue(?:sday)?|Wed(?:nesday)?|Thu(?:rsday)?|Fri(?:day)?|Sat(?:urday)?|Sun(?:day)?)
 
 # Years?
 YEAR (?>\d\d){1,2}
 # Time: HH:MM:SS
 #TIME \d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?
 # TIME %{POSINT<24}:%{POSINT<60}(?::%{POSINT<60}(?:\.%{POSINT})?)?
 HOUR (?:2[0123]|[01]?[0-9])
 MINUTE (?:[0-5][0-9])
 # '60' is a leap second in most time standards and thus is valid.
 SECOND (?:(?:[0-5]?[0-9]|60)(?:[:.,][0-9]+)?)
 TIME (?!<[0-9])%{HOUR}:%{MINUTE}(?::%{SECOND})(?![0-9])
 # datestamp is YYYY/MM/DD-HH:MM:SS.UUUU (or something like it)
 DATE_US %{MONTHNUM}[/-]%{MONTHDAY}[/-]%{YEAR}
 DATE_EU %{MONTHDAY}[./-]%{MONTHNUM}[./-]%{YEAR}
 DATESTAMP_US %{DATE_US}[- ]%{TIME}
 DATESTAMP_EU %{DATE_EU}[- ]%{TIME}
 ISO8601_TIMEZONE (?:Z|[+-]%{HOUR}(?::?%{MINUTE}))
 ISO8601_SECOND (?:%{SECOND}|60)
 TIMESTAMP_ISO8601 %{YEAR}-%{MONTHNUM}-%{MONTHDAY}[T ]%{HOUR}:?%{MINUTE}(?::?%{SECOND})?%{ISO8601_TIMEZONE}?
 TZ (?:[PMCE][SD]T|UTC)
 DATESTAMP_RFC822 %{DAY} %{MONTH} %{MONTHDAY} %{YEAR} %{TIME} %{TZ}
 DATESTAMP_RFC2822 %{DAY}, %{MONTHDAY} %{MONTH} %{YEAR} %{TIME} %{ISO8601_TIMEZONE}
 DATESTAMP_OTHER %{DAY} %{MONTH} %{MONTHDAY} %{TIME} %{TZ} %{YEAR}
 DATESTAMP_EVENTLOG %{YEAR}%{MONTHNUM2}%{MONTHDAY}%{HOUR}%{MINUTE}%{SECOND}
 CISCOTIMESTAMP %{MONTH} %{MONTHDAY} %{TIME}
 
 # Syslog Dates: Month Day HH:MM:SS
 SYSLOGTIMESTAMP %{MONTH} +%{MONTHDAY} %{TIME}
 PROG (?:[\w._/%-]+)
 SYSLOGPROG %{PROG:program}(?:\[%{POSINT:pid}\])?
 SYSLOGHOST %{IPORHOST}
 SYSLOGFACILITY <%{NONNEGINT:facility}.%{NONNEGINT:priority}>
 HTTPDATE %{MONTHDAY}/%{MONTH}/%{YEAR}:%{TIME} %{INT}
 
 # Shortcuts
 QS %{QUOTEDSTRING:UNWANTED}
 
 # Log formats
 SYSLOGBASE %{SYSLOGTIMESTAMP:timestamp} (?:%{SYSLOGFACILITY} )?%{SYSLOGHOST:logsource} %{SYSLOGPROG}:
 
 MESSAGESLOG %{SYSLOGBASE} %{DATA}
 
 COMMONAPACHELOG %{IPORHOST:clientip} %{USER:ident} %{USER:auth} \[%{HTTPDATE:timestamp}\] "(?:%{WORD:verb} %{NOTSPACE:request}(?: HTTP/%{NUMBER:httpversion})?|%{DATA:rawrequest})" %{NUMBER:response} (?:%{Bytes:bytes=%{NUMBER}|-})
 COMBINEDAPACHELOG %{COMMONAPACHELOG} %{QS:referrer} %{QS:agent}
 COMMONAPACHELOG_DATATYPED %{IPORHOST:clientip} %{USER:ident;boolean} %{USER:auth} \[%{HTTPDATE:timestamp;date;dd/MMM/yyyy:HH:mm:ss Z}\] "(?:%{WORD:verb;string} %{NOTSPACE:request}(?: HTTP/%{NUMBER:httpversion;float})?|%{DATA:rawrequest})" %{NUMBER:response;int} (?:%{NUMBER:bytes;long}|-)
 
 
 # Log Levels
 LOGLEVEL ([A|a]lert|ALERT|[T|t]race|TRACE|[D|d]ebug|DEBUG|[N|n]otice|NOTICE|[I|i]nfo|INFO|[W|w]arn?(?:ing)?|WARN?(?:ING)?|[E|e]rr?(?:or)?|ERR?(?:OR)?|[C|c]rit?(?:ical)?|CRIT?(?:ICAL)?|[F|f]atal|FATAL|[S|s]evere|SEVERE|EMERG(?:ENCY)?|[Ee]merg(?:ency)?)

Scrittura di classificatori XML personalizzati

XMLdefinisce la struttura di un documento con l'uso di tag nel file. Con un classificatore XML personalizzato, è possibile specificare il nome del tag utilizzato per definire una riga.

Valori di classificazione personalizzati per un classificatore XML

Quando si definisce un XML classificatore, si forniscono i seguenti valori per AWS Glue creare il classificatore. Il campo classificazione di questo classificatore è impostato su xml.

Nome

Nome del classificatore.

Tag di riga

Il nome del XML tag che definisce una riga della tabella nel XML documento, senza parentesi angolari. < > Il nome deve essere conforme alle XML regole relative a un tag.

Nota

L'elemento contenente i dati di riga non può essere un elemento vuoto che si auto-chiude. Questo elemento vuoto, ad esempio, non viene analizzato da AWS Glue:



            <row att1=”xx” att2=”yy” />

È possibile scrivere gli elementi vuoti come segue:



            <row att1=”xx” att2=”yy”> </row>

AWS Glue tiene traccia della data e dell'ora di creazione, della data e dell'ora dell'ultimo aggiornamento e della versione del classificatore.

Ad esempio, supponiamo di avere il seguente XML file. Per creare una tabella AWS Glue che contiene solo le colonne per autore e titolo, crea un classificatore nella console AWS Glue con Row tag (Tag di riga) impostato su AnyCompany. Aggiungi ed esegui quindi un crawler che usa questo classificatore personalizzato.



<?xml version="1.0"?>
<catalog>
   <book id="bk101">
     <AnyCompany>
       <author>Rivera, Martha</author>
       <title>AnyCompany Developer Guide</title>
     </AnyCompany>
   </book>
   <book id="bk102">
     <AnyCompany>   
       <author>Stiles, John</author>
       <title>Style Guide for AnyCompany</title>
     </AnyCompany>
   </book>
</catalog>

Scrittura di JSON classificatori personalizzati

JSONè un formato di scambio di dati. Definisce le strutture di dati con coppie nome-valore o con un elenco ordinato di valori. Con un classificatore JSON personalizzato, puoi specificare il JSON percorso di una struttura di dati utilizzata per definire lo schema della tabella.

Valori dei classificatori personalizzati in AWS Glue

Quando si definisce un JSON classificatore, si forniscono i seguenti valori per AWS Glue creare il classificatore. Il campo classificazione di questo classificatore è impostato su json.

Nome

Nome del classificatore.

JSONpercorso

Un JSON percorso che punta a un oggetto utilizzato per definire uno schema di tabella. Il JSON percorso può essere scritto in notazione a punti o tra parentesi. Sono supportati i seguenti operatori:

Operatore	Descrizione
`$`	Elemento principale di un oggetto. JSON Avvia tutte le espressioni del percorso
`*`	Carattere jolly. Disponibile ovunque sia richiesto un nome o un numero nel JSON percorso.
`.<name>`	Figlio con notazione dot. Specifica un campo secondario in un JSON oggetto.
`['<name>']`	Figlio con notazione parentesi. Specifica il campo secondario in un JSON oggetto. Solo un singolo campo figlio può essere specificato.
`[<number>]`	Indice di matrice. Specifica il valore di una matrice in base all'indice.

AWS Glue tiene traccia della data e dell'ora di creazione, della data e dell'ora dell'ultimo aggiornamento e della versione del classificatore.

Esempio Utilizzo di un JSON classificatore per estrarre i record da un array

Supponiamo che i JSON dati siano una matrice di record. Ad esempio, le prime righe del file potrebbero apparire come segue:



[
  {
    "type": "constituency",
    "id": "ocd-division\/country:us\/state:ak",
    "name": "Alaska"
  },
  {
    "type": "constituency",
    "id": "ocd-division\/country:us\/state:al\/cd:1",
    "name": "Alabama's 1st congressional district"
  },
  {
    "type": "constituency",
    "id": "ocd-division\/country:us\/state:al\/cd:2",
    "name": "Alabama's 2nd congressional district"
  },
  {
    "type": "constituency",
    "id": "ocd-division\/country:us\/state:al\/cd:3",
    "name": "Alabama's 3rd congressional district"
  },
  {
    "type": "constituency",
    "id": "ocd-division\/country:us\/state:al\/cd:4",
    "name": "Alabama's 4th congressional district"
  },
  {
    "type": "constituency",
    "id": "ocd-division\/country:us\/state:al\/cd:5",
    "name": "Alabama's 5th congressional district"
  },
  {
    "type": "constituency",
    "id": "ocd-division\/country:us\/state:al\/cd:6",
    "name": "Alabama's 6th congressional district"
  },
  {
    "type": "constituency",
    "id": "ocd-division\/country:us\/state:al\/cd:7",
    "name": "Alabama's 7th congressional district"
  },
  {
    "type": "constituency",
    "id": "ocd-division\/country:us\/state:ar\/cd:1",
    "name": "Arkansas's 1st congressional district"
  },
  {
    "type": "constituency",
    "id": "ocd-division\/country:us\/state:ar\/cd:2",
    "name": "Arkansas's 2nd congressional district"
  },
  {
    "type": "constituency",
    "id": "ocd-division\/country:us\/state:ar\/cd:3",
    "name": "Arkansas's 3rd congressional district"
  },
  {
    "type": "constituency",
    "id": "ocd-division\/country:us\/state:ar\/cd:4",
    "name": "Arkansas's 4th congressional district"
  }
]

Quando si esegue un crawler utilizzando il JSON classificatore integrato, per definire lo schema viene utilizzato l'intero file. Poiché non specificate un JSON percorso, il crawler tratta i dati come un unico oggetto, ovvero solo un array. Ad esempio, lo schema potrebbe apparire come segue:



root
|-- record: array

Tuttavia, per creare uno schema basato su ogni record dell'JSONarray, create un JSON classificatore personalizzato e specificate il percorso come. JSON $[*] Quando specificate questo JSON percorso, il classificatore interroga tutti i 12 record dell'array per determinare lo schema. Lo schema risultante contiene campi separati per ciascun oggetto, analogamente all'esempio seguente:



root
|-- type: string
|-- id: string
|-- name: string

Esempio Utilizzo di un JSON classificatore per esaminare solo parti di un file

Supponiamo che i JSON dati seguano lo schema del JSON file di esempio s3://awsglue-datasets/examples/us-legislators/all/areas.json tratto da http://everypolitician.org/. Gli oggetti di esempio contenuti nel JSON file hanno il seguente aspetto:



{
  "type": "constituency",
  "id": "ocd-division\/country:us\/state:ak",
  "name": "Alaska"
}
{
  "type": "constituency",
  "identifiers": [
    {
      "scheme": "dmoz",
      "identifier": "Regional\/North_America\/United_States\/Alaska\/"
    },
    {
      "scheme": "freebase",
      "identifier": "\/m\/0hjy"
    },
    {
      "scheme": "fips",
      "identifier": "US02"
    },
    {
      "scheme": "quora",
      "identifier": "Alaska-state"
    },
    {
      "scheme": "britannica",
      "identifier": "place\/Alaska"
    },
    {
      "scheme": "wikidata",
      "identifier": "Q797"
    }
  ],
  "other_names": [
    {
      "lang": "en",
      "note": "multilingual",
      "name": "Alaska"
    },
    {
      "lang": "fr",
      "note": "multilingual",
      "name": "Alaska"
    },
    {
      "lang": "nov",
      "note": "multilingual",
      "name": "Alaska"
    }
  ],
  "id": "ocd-division\/country:us\/state:ak",
  "name": "Alaska"
}

Quando esegui un crawler utilizzando il JSON classificatore integrato, l'intero file viene utilizzato per creare lo schema. È possibile ritrovarsi con uno schema di questo tipo:



root
|-- type: string
|-- id: string
|-- name: string
|-- identifiers: array
|    |-- element: struct
|    |    |-- scheme: string
|    |    |-- identifier: string
|-- other_names: array
|    |-- element: struct
|    |    |-- lang: string
|    |    |-- note: string
|    |    |-- name: string

Tuttavia, per creare uno schema utilizzando solo l'oggetto "id", create un JSON classificatore personalizzato e specificate il percorso come. JSON $.id Lo schema sarà così basato solo sul campo "id":



root
|-- record: string

Le prime righe di dati estratte con questo schema hanno l'aspetto seguente:



{"record": "ocd-division/country:us/state:ak"}
{"record": "ocd-division/country:us/state:al/cd:1"}
{"record": "ocd-division/country:us/state:al/cd:2"}
{"record": "ocd-division/country:us/state:al/cd:3"}
{"record": "ocd-division/country:us/state:al/cd:4"}
{"record": "ocd-division/country:us/state:al/cd:5"}
{"record": "ocd-division/country:us/state:al/cd:6"}
{"record": "ocd-division/country:us/state:al/cd:7"}
{"record": "ocd-division/country:us/state:ar/cd:1"}
{"record": "ocd-division/country:us/state:ar/cd:2"}
{"record": "ocd-division/country:us/state:ar/cd:3"}
{"record": "ocd-division/country:us/state:ar/cd:4"}
{"record": "ocd-division/country:us/state:as"}
{"record": "ocd-division/country:us/state:az/cd:1"}
{"record": "ocd-division/country:us/state:az/cd:2"}
{"record": "ocd-division/country:us/state:az/cd:3"}
{"record": "ocd-division/country:us/state:az/cd:4"}
{"record": "ocd-division/country:us/state:az/cd:5"}
{"record": "ocd-division/country:us/state:az/cd:6"}
{"record": "ocd-division/country:us/state:az/cd:7"}

Per creare uno schema basato su un oggetto profondamente annidato, ad esempio "identifier,» nel JSON file, potete creare un JSON classificatore personalizzato e specificare il JSON percorso come. $.identifiers[*].identifier Sebbene lo schema sia simile all'esempio precedente, si basa su un oggetto diverso nel JSON file.

Lo schema ha il seguente aspetto:



root
|-- record: string

Elencando le prime righe di dati della tabella è possibile vedere che lo schema si basa sui dati nell'oggetto "identifier":



{"record": "Regional/North_America/United_States/Alaska/"}
{"record": "/m/0hjy"}
{"record": "US02"}
{"record": "5879092"}
{"record": "4001016-8"}
{"record": "destination/alaska"}
{"record": "1116270"}
{"record": "139487266"}
{"record": "n79018447"}
{"record": "01490999-8dec-4129-8254-eef6e80fadc3"}
{"record": "Alaska-state"}
{"record": "place/Alaska"}
{"record": "Q797"}
{"record": "Regional/North_America/United_States/Alabama/"}
{"record": "/m/0gyh"}
{"record": "US01"}
{"record": "4829764"}
{"record": "4084839-5"}
{"record": "161950"}
{"record": "131885589"}

Per creare una tabella basata su un altro oggetto profondamente annidato, ad esempio il campo name "" nell'array other_names "" del JSON file, è possibile creare un JSON classificatore personalizzato e specificare il JSON percorso come. $.other_names[*].name Sebbene lo schema sia simile all'esempio precedente, si basa su un oggetto diverso nel JSON file. Lo schema ha il seguente aspetto:



root
|-- record: string

Elencando le prime righe di dati della tabella è possibile vedere che lo schema si basa sui dati nell'oggetto "name" nella matrice "other_names":



{"record": "Alaska"}
{"record": "Alaska"}
{"record": "Аляска"}
{"record": "Alaska"}
{"record": "Alaska"}
{"record": "Alaska"}
{"record": "Alaska"}
{"record": "Alaska"}
{"record": "Alaska"}
{"record": "ألاسكا"}
{"record": "ܐܠܐܣܟܐ"}
{"record": "الاسكا"}
{"record": "Alaska"}
{"record": "Alyaska"}
{"record": "Alaska"}
{"record": "Alaska"}
{"record": "Штат Аляска"}
{"record": "Аляска"}
{"record": "Alaska"}
{"record": "আলাস্কা"}

Scrittura di classificatori CSV personalizzati

CSVI classificatori personalizzati consentono di specificare i tipi di dati per ogni colonna nel campo del classificatore csv personalizzato. È possibile specificare il tipo di dati di ogni colonna separato da una virgola. Specificando i tipi di dati, è possibile sovrascrivere i tipi di dati dedotti dai crawler e garantire che i dati vengano classificati in modo appropriato.

È possibile impostare l' SerDe elaborazione CSV nel classificatore, che verrà applicato nel Data Catalog.

Quando crei un classificatore personalizzato, puoi anche riutilizzare il classificatore per diversi crawler.

Per i file csv con solo intestazioni (nessun dato), questi file verranno classificati in UNKNOWN quanto non vengono fornite informazioni sufficienti. Se specifichi che CSV «Ha intestazioni» nell'opzione Intestazioni delle colonne e fornisci i tipi di dati, possiamo classificare questi file correttamente.

Puoi utilizzare un CSV classificatore personalizzato per dedurre lo schema di vari tipi di dati. CSV Gli attributi personalizzati che puoi fornire per il classificatore includono delimitatori, un'CSV SerDe opzione, opzioni relative all'intestazione e se eseguire determinate convalide sui dati.

Valori dei classificatori personalizzati in AWS Glue

Quando si definisce un CSV classificatore, si forniscono i seguenti valori per creare il classificatore. AWS Glue Il campo classificazione di questo classificatore è impostato su csv.

Nome del classificatore: Nome del classificatore.
CSVSerde: Imposta il valore SerDe per l'elaborazione CSV nel classificatore, che verrà applicato nel Data Catalog. Le opzioni sono Open CSV SerDe, Lazy Simple e SerDe None. È possibile specificare il valore None quando si desidera che il crawler esegua il rilevamento.
Delimitatore di colonna: Un simbolo personalizzato per indicare il separatore di ogni voce di colonna nella riga. Fornisci un carattere unicode. Se non riesci a digitare il delimitatore, puoi copiarlo e incollarlo. Questo vale per i caratteri stampabili, compresi quelli non supportati dal sistema (in genere indicati come □).
Simbolo di virgolette: Un simbolo personalizzato per indicare la combinazione dei contenuti in un singolo valore di colonna. Deve essere diverso dal delimitatore di colonna. Fornisci un carattere unicode. Se non riesci a digitare il delimitatore, puoi copiarlo e incollarlo. Questo vale per i caratteri stampabili, compresi quelli non supportati dal sistema (in genere indicati come □).
Intestazioni di colonna: Indica il comportamento in base al quale le intestazioni delle colonne devono essere rilevate nel CSV file. Se il CSV file personalizzato contiene intestazioni di colonna, inserisci un elenco di intestazioni di colonna delimitato da virgole.
Opzioni di elaborazione: consenti i file con una singola colonna: Abilita l'elaborazione dei file che contengono una sola colonna.
Opzioni di elaborazione: taglia lo spazio vuoto prima dell'identificazione dei valori di colonna: Specifica se tagliare i valori prima di individuare il tipo dei valori di colonna.
Tipi di dati personalizzati: facoltativo: Inserisci il tipo di dati personalizzato separato da una virgola. Specificate i tipi di dati personalizzati nel file. CSV Il tipo di dati personalizzato deve essere un tipo di dati supportato. I tipi di dati supportati sono: «BINARY», «», «BOOLEAN», «DATE», «», «DECIMAL», «DOUBLE», «FLOAT», «», «INT», «LONG», «SHORT». STRING TIMESTAMP I tipi di dati non supportati mostreranno un errore.

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Definizione e gestione dei classificatori

Creazione di classificatori sulla console