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à.
# Migrazione di framework di big data con AWS Schema Conversion Tool
Puoi usare il AWS Schema Conversion Tool (AWS SCT) per migrare i framework di big data verso. Cloud AWS
Attualmente AWS SCT supporta la migrazione di cluster Hadoop su Amazon EMR e Amazon S3. Questo processo di migrazione include i servizi Hive e HDFS.
Inoltre, puoi utilizzarlo AWS SCT per automatizzare la conversione dei flussi di lavoro di orchestrazione di Apache Oozie in. AWS Step Functions
**Topics**
+ [Migrazione dei carichi di lavoro Hadoop su Amazon EMR con AWS Schema Conversion Tool](big-data-hadoop.md)
+ [Conversione dei flussi di lavoro di Ozie in with AWS Step Functions AWS Schema Conversion Tool](big-data-oozie.md)
# Migrazione dei carichi di lavoro Hadoop su Amazon EMR con AWS Schema Conversion Tool
Per migrare i cluster Apache Hadoop, assicurati di utilizzare la versione 1.0.670 o successiva. AWS SCT Inoltre, acquisisci familiarità con l'interfaccia a riga di comando (CLI) di. AWS SCT Per ulteriori informazioni, consulta [Riferimento CLI per AWS Schema Conversion Tool](CHAP_Reference.md).
**Topics**
+ [Panoramica sulla migrazione](#big-data-hadoop-migration-overview)
+ [Passaggio 1: Connect ai cluster Hadoop](#big-data-hadoop-connect-to-databases)
+ [Fase 2: Impostare le regole di mappatura](#big-data-hadoop-mapping-rules)
+ [Fase 3: Creare un rapporto di valutazione](#big-data-hadoop-assessment-report)
+ [Fase 4: Esegui la migrazione del cluster Apache Hadoop su Amazon EMR con AWS SCT](#big-data-hadoop-migrate)
+ [Esecuzione dello script CLI](#big-data-hadoop-run-migration)
+ [Gestione del progetto di migrazione dei Big Data](#big-data-hadoop-manage-project)
## Panoramica sulla migrazione
L'immagine seguente mostra il diagramma dell'architettura della migrazione da Apache Hadoop ad Amazon EMR.
![\[Il diagramma dell'architettura della migrazione Hadoop\]](http://docs.aws.amazon.com/it_it/SchemaConversionTool/latest/userguide/images/hadoop-migration-architecture-diagram.png)
AWS SCT migra dati e metadati dal cluster Hadoop di origine a un bucket Amazon S3. Successivamente, AWS SCT utilizza i metadati Hive di origine per creare oggetti di database nel servizio Amazon EMR Hive di destinazione. Facoltativamente, puoi configurare Hive per utilizzarlo come metastore. AWS Glue Data Catalog In questo caso, AWS SCT migra i metadati Hive di origine in. AWS Glue Data Catalog
Quindi, puoi utilizzarli AWS SCT per migrare i dati da un bucket Amazon S3 al servizio Amazon EMR HDFS di destinazione. In alternativa, puoi lasciare i dati nel tuo bucket Amazon S3 e utilizzarli come repository di dati per i tuoi carichi di lavoro Hadoop.
Per avviare la migrazione di Hapood, devi creare ed eseguire lo script AWS SCT CLI. Questo script include il set completo di comandi per eseguire la migrazione. È possibile scaricare e modificare un modello dello script di migrazione Hadoop. Per ulteriori informazioni, consulta [Ottenere scenari CLI](CHAP_Reference.md#CHAP_Reference.Scenario).
Assicurati che lo script includa i seguenti passaggi in modo da poter eseguire la migrazione da Apache Hadoop ad Amazon S3 e Amazon EMR.
## Passaggio 1: Connect ai cluster Hadoop
Per iniziare la migrazione del tuo cluster Apache Hadoop, crea un nuovo progetto. AWS SCT Successivamente, connettiti ai cluster di origine e di destinazione. Assicurati di creare e fornire AWS le risorse di destinazione prima di iniziare la migrazione.
In questo passaggio, si utilizzano i seguenti comandi AWS SCT CLI.
+ `CreateProject`— per creare un nuovo AWS SCT progetto.
+ `AddSourceCluster`— per connettersi al cluster Hadoop di origine del progetto. AWS SCT
+ `AddSourceClusterHive`— per connettersi al servizio Hive di origine del progetto.
+ `AddSourceClusterHDFS`— per connettersi al servizio HDFS di origine del progetto.
+ `AddTargetCluster`— per connetterti al cluster Amazon EMR di destinazione del tuo progetto.
+ `AddTargetClusterS3`— per aggiungere il bucket Amazon S3 al tuo progetto.
+ `AddTargetClusterHive`— per connetterti al servizio Hive di destinazione del tuo progetto
+ `AddTargetClusterHDFS`— per connettersi al servizio HDFS di destinazione del progetto
Per esempi di utilizzo di questi comandi AWS SCT CLI, vedere. [Connessione ad Apache Hadoop](CHAP_Source.Hadoop.md)
Quando esegui il comando che si connette a un cluster di origine o di destinazione, AWS SCT tenta di stabilire la connessione a questo cluster. Se il tentativo di connessione fallisce, AWS SCT interrompe l'esecuzione dei comandi dallo script CLI e visualizza un messaggio di errore.
## Fase 2: Impostare le regole di mappatura
Dopo esserti connesso ai cluster di origine e di destinazione, configura le regole di mappatura. Una regola di mappatura definisce l'obiettivo di migrazione per un cluster di origine. Assicurati di impostare le regole di mappatura per tutti i cluster di origine che hai aggiunto al progetto. AWS SCT Per ulteriori informazioni sulle regole di mappatura, consulta. [Mappatura dei tipi di dati in AWS Schema Conversion Tool](CHAP_Mapping.md)
In questo passaggio, si utilizza il `AddServerMapping` comando. Questo comando utilizza due parametri che definiscono i cluster di origine e di destinazione. È possibile utilizzare il `AddServerMapping` comando con il percorso esplicito degli oggetti del database o con i nomi di un oggetto. Come prima opzione, includi il tipo di oggetto e il suo nome. Per la seconda opzione, includete solo i nomi degli oggetti.
+ `sourceTreePath`— il percorso esplicito degli oggetti del database di origine.
`targetTreePath`— il percorso esplicito degli oggetti del database di destinazione.
+ `sourceNamePath`— il percorso che include solo i nomi degli oggetti di origine.
`targetNamePath`— il percorso che include solo i nomi degli oggetti di destinazione.
Il seguente esempio di codice crea una regola di mappatura utilizzando percorsi espliciti per il database `testdb` Hive di origine e il cluster EMR di destinazione.
```
AddServerMapping
-sourceTreePath: 'Clusters.HADOOP_SOURCE.HIVE_SOURCE.Databases.testdb'
-targetTreePath: 'Clusters.HADOOP_TARGET.HIVE_TARGET'
/
```
È possibile utilizzare questo esempio e gli esempi seguenti in Windows. Per eseguire i comandi CLI in Linux, assicurati di aver aggiornato i percorsi dei file in modo appropriato per il tuo sistema operativo.
Il seguente esempio di codice crea una regola di mappatura utilizzando i percorsi che includono solo i nomi degli oggetti.
```
AddServerMapping
-sourceNamePath: 'HADOOP_SOURCE.HIVE_SOURCE.testdb'
-targetNamePath: 'HADOOP_TARGET.HIVE_TARGET'
/
```
Puoi scegliere Amazon EMR o Amazon S3 come destinazione per il tuo oggetto di origine. Per ogni oggetto sorgente, puoi scegliere solo una destinazione in un singolo AWS SCT progetto. Per modificare la destinazione di migrazione per un oggetto di origine, eliminate la regola di mappatura esistente e quindi create una nuova regola di mappatura. Per eliminare una regola di mappatura, utilizzare il comando. `DeleteServerMapping` Questo comando utilizza uno dei due parametri seguenti.
+ `sourceTreePath`— il percorso esplicito degli oggetti del database di origine.
+ `sourceNamePath`— il percorso che include solo i nomi degli oggetti di origine.
Per ulteriori informazioni sui `DeleteServerMapping` comandi `AddServerMapping` and, consulta la [AWS Schema Conversion Tool CLI Reference](https://s3.amazonaws.com/publicsctdownload/AWS+SCT+CLI+Reference.pdf).
## Fase 3: Creare un rapporto di valutazione
Prima di iniziare la migrazione, ti consigliamo di creare un rapporto di valutazione. Questo rapporto riassume tutte le attività di migrazione e descrive in dettaglio le azioni che emergeranno durante la migrazione. Per assicurarti che la migrazione non vada a buon fine, visualizza questo rapporto e risolvi le azioni da intraprendere prima della migrazione. Per ulteriori informazioni, consulta [Report di valutazione](CHAP_AssessmentReport.md).
In questo passaggio, si utilizza il `CreateMigrationReport` comando. Questo comando utilizza due parametri. Il `treePath` parametro è obbligatorio e il `forceMigrate` parametro è facoltativo.
+ `treePath`— il percorso esplicito degli oggetti del database di origine per i quali si salva una copia del rapporto di valutazione.
+ `forceMigrate`— se impostato su`true`, AWS SCT continua la migrazione anche se il progetto include una cartella HDFS e una tabella Hive che fanno riferimento allo stesso oggetto. Il valore predefinito è `false`.
È quindi possibile salvare una copia del rapporto di valutazione come file PDF o file con valori separati da virgole (CSV). A tale scopo, utilizzate il comando or. `SaveReportPDF` `SaveReportCSV`
Il `SaveReportPDF` comando salva una copia del rapporto di valutazione come file PDF. Questo comando utilizza quattro parametri. Il `file` parametro è obbligatorio, gli altri parametri sono opzionali.
+ `file`— il percorso del file PDF e il suo nome.
+ `filter`— il nome del filtro creato in precedenza per definire l'ambito degli oggetti di origine da migrare.
+ `treePath`— il percorso esplicito degli oggetti del database di origine per i quali salvate una copia del rapporto di valutazione.
+ `namePath`— il percorso che include solo i nomi degli oggetti di destinazione per i quali si salva una copia del rapporto di valutazione.
Il `SaveReportCSV` comando salva il rapporto di valutazione in tre file CSV. Questo comando utilizza quattro parametri. Il `directory` parametro è obbligatorio, gli altri parametri sono opzionali.
+ `directory`— il percorso della cartella in cui vengono AWS SCT salvati i file CSV.
+ `filter`— il nome del filtro creato in precedenza per definire l'ambito degli oggetti di origine da migrare.
+ `treePath`— il percorso esplicito degli oggetti del database di origine per i quali salvate una copia del rapporto di valutazione.
+ `namePath`— il percorso che include solo i nomi degli oggetti di destinazione per i quali si salva una copia del rapporto di valutazione.
Il seguente esempio di codice salva una copia del rapporto di valutazione nel `c:\sct\ar.pdf` file.
```
SaveReportPDF
-file:'c:\sct\ar.pdf'
/
```
Il seguente esempio di codice salva una copia del rapporto di valutazione come file CSV nella `c:\sct` cartella.
```
SaveReportCSV
-file:'c:\sct'
/
```
Per ulteriori informazioni sui `SaveReportCSV` comandi `SaveReportPDF` and, consulta la [AWS Schema Conversion Tool CLI Reference](https://s3.amazonaws.com/publicsctdownload/AWS+SCT+CLI+Reference.pdf).
## Fase 4: Esegui la migrazione del cluster Apache Hadoop su Amazon EMR con AWS SCT
Dopo aver configurato il AWS SCT progetto, avvia la migrazione del cluster Apache Hadoop locale verso. Cloud AWS
In questo passaggio, si utilizzano i comandi`Migrate`, `MigrationStatus` e. `ResumeMigration`
Il `Migrate` comando migra gli oggetti di origine nel cluster di destinazione. Questo comando utilizza quattro parametri. Assicurati di specificare il `treePath` parametro `filter` o. Gli altri parametri sono opzionali.
+ `filter`— il nome del filtro creato in precedenza per definire l'ambito degli oggetti di origine da migrare.
+ `treePath`— il percorso esplicito degli oggetti del database di origine per i quali salvate una copia del rapporto di valutazione.
+ `forceLoad`— se impostato su`true`, carica AWS SCT automaticamente gli alberi di metadati del database durante la migrazione. Il valore predefinito è `false`.
+ `forceMigrate`— se impostato su`true`, AWS SCT continua la migrazione anche se il progetto include una cartella HDFS e una tabella Hive che fanno riferimento allo stesso oggetto. Il valore predefinito è `false`.
Il `MigrationStatus` comando restituisce le informazioni sull'avanzamento della migrazione. Per eseguire questo comando, inserisci il nome del tuo progetto di migrazione per il `name` parametro. Hai specificato questo nome nel `CreateProject` comando.
Il `ResumeMigration` comando riprende la migrazione interrotta avviata utilizzando il comando. `Migrate` Il `ResumeMigration` comando non utilizza parametri. Per riprendere la migrazione, è necessario connettersi ai cluster di origine e di destinazione. Per ulteriori informazioni, consulta [Gestione del progetto di migrazione](#big-data-hadoop-manage-project).
Il seguente esempio di codice migra i dati dal servizio HDFS di origine ad Amazon EMR.
```
Migrate
-treePath: 'Clusters.HADOOP_SOURCE.HDFS_SOURCE'
-forceMigrate: 'true'
/
```
## Esecuzione dello script CLI
Dopo aver finito di modificare lo script AWS SCT CLI, salvalo come file con estensione. `.scts` Ora puoi eseguire lo script dalla `app` cartella del percorso di AWS SCT installazione. A tale scopo, utilizzare il comando seguente.
```
RunSCTBatch.cmd --pathtoscts "C:\script_path\hadoop.scts"
```
Nell'esempio precedente, sostituite *script\$1path* con il percorso del file con lo script CLI. Per ulteriori informazioni sull'esecuzione degli script CLI in AWS SCT, vedere. [Modalità script](CHAP_Reference.md#CHAP_Reference.ScriptMode)
## Gestione del progetto di migrazione dei Big Data
Dopo aver completato la migrazione, puoi salvare e modificare il tuo AWS SCT progetto per usi futuri.
Per salvare il AWS SCT progetto, usa il `SaveProject` comando. Questo comando non utilizza parametri.
Il seguente esempio di codice salva il AWS SCT progetto.
```
SaveProject
/
```
Per aprire il AWS SCT progetto, usa il `OpenProject` comando. Questo comando utilizza un parametro obbligatorio. Per il `file` parametro, inserite il percorso del file di AWS SCT progetto e il relativo nome. Avete specificato il nome del progetto nel `CreateProject` comando. Assicurati di aggiungere l'`.scts`estensione al nome del file di progetto per eseguire il `OpenProject` comando.
Il seguente esempio di codice apre il `hadoop_emr` progetto dalla `c:\sct` cartella.
```
OpenProject
-file: 'c:\sct\hadoop_emr.scts'
/
```
Dopo aver aperto il AWS SCT progetto, non è necessario aggiungere i cluster di origine e di destinazione perché li avete già aggiunti al progetto. Per iniziare a lavorare con i cluster di origine e di destinazione, devi connetterti ad essi. A tale scopo, si utilizzano i `ConnectTargetCluster` comandi `ConnectSourceCluster` and. Questi comandi utilizzano gli stessi parametri dei `AddTargetCluster` comandi `AddSourceCluster` and. Puoi modificare lo script CLI e sostituire il nome di questi comandi lasciando l'elenco dei parametri senza modifiche.
Il seguente esempio di codice si connette al cluster Hadoop di origine.
```
ConnectSourceCluster
-name: 'HADOOP_SOURCE'
-vendor: 'HADOOP'
-host: 'hadoop_address'
-port: '22'
-user: 'hadoop_user'
-password: 'hadoop_password'
-useSSL: 'true'
-privateKeyPath: 'c:\path\name.pem'
-passPhrase: 'hadoop_passphrase'
/
```
Il seguente esempio di codice si connette al cluster Amazon EMR di destinazione.
```
ConnectTargetCluster
-name: 'HADOOP_TARGET'
-vendor: 'AMAZON_EMR'
-host: 'ec2-44-44-55-66.eu-west-1.EXAMPLE.amazonaws.com'
-port: '22'
-user: 'emr_user'
-password: 'emr_password'
-useSSL: 'true'
-privateKeyPath: 'c:\path\name.pem'
-passPhrase: '1234567890abcdef0!'
-s3Name: 'S3_TARGET'
-accessKey: 'AKIAIOSFODNN7EXAMPLE'
-secretKey: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY'
-region: 'eu-west-1'
-s3Path: 'doc-example-bucket/example-folder'
/
```
Nell'esempio precedente, sostituiscilo *hadoop\$1address* con l'indirizzo IP del tuo cluster Hadoop. Se necessario, configura il valore della variabile di porta. Quindi, sostituisci *hadoop\$1user* e *hadoop\$1password* con il nome del tuo utente Hadoop e la password per questo utente. Ad esempio*path\$1name*, inserisci il nome e il percorso del file PEM per il tuo cluster Hadoop di origine. Per ulteriori informazioni sull'aggiunta dei cluster di origine e di destinazione, consulta. [Connessione ai database Apache Hadoop con AWS Schema Conversion Tool](CHAP_Source.Hadoop.md)
Dopo esserti connesso ai cluster Hadoop di origine e di destinazione, devi connetterti ai servizi Hive e HDFS, nonché al tuo bucket Amazon S3. A tale scopo, si utilizzano i comandi,,, e`ConnectSourceClusterHive`. `ConnectSourceClusterHdfs` `ConnectTargetClusterHive` `ConnectTargetClusterHdfs` `ConnectTargetClusterS3` Questi comandi utilizzano gli stessi parametri dei comandi che hai usato per aggiungere i servizi Hive e HDFS e il bucket Amazon S3 al tuo progetto. Modifica lo script CLI per sostituire il `Add` prefisso con `Connect` nei nomi dei comandi.
# Conversione dei flussi di lavoro di Ozie in with AWS Step Functions AWS Schema Conversion Tool
Per convertire i flussi di lavoro di Apache Oozie, assicurati di utilizzare la versione 1.0.671 o successiva. AWS SCT Inoltre, acquisisci familiarità con l'interfaccia a riga di comando (CLI) di. AWS SCT Per ulteriori informazioni, consulta [Riferimento CLI per AWS Schema Conversion Tool](CHAP_Reference.md).
**Topics**
+ [Panoramica della conversione](#big-data-oozie-overview)
+ [Fase 1: Connect ai servizi di origine e di destinazione](#big-data-oozie-connect-to-databases)
+ [Fase 2: Impostare le regole di mappatura](#big-data-oozie-mapping-rules)
+ [Fase 3: Configurazione dei parametri](#big-data-oozie-configure-parameters)
+ [Fase 4: creazione di un report di valutazione](#big-data-oozie-assessment-report)
+ [Passaggio 5: Convertite i flussi di lavoro di Apache Oozie in with AWS Step Functions AWS SCT](#big-data-oozie-migrate)
+ [Esecuzione dello script CLI](#big-data-oozie-run-migration)
+ [Nodi Apache Oozie in cui è possibile eseguire la conversione AWS SCT AWS Step Functions](#big-data-oozie-supported-nodes)
## Panoramica della conversione
Il codice sorgente di Apache Oozie include nodi di azione, nodi di flusso di controllo e proprietà del lavoro. I nodi di azione definiscono i processi che esegui nel flusso di lavoro di Apache Oozie. Quando si utilizza Apache Oozie per orchestrare il cluster Apache Hadoop, un nodo di azione include un job Hadoop. I nodi di flusso di controllo forniscono un meccanismo per controllare il percorso del flusso di lavoro. I nodi del flusso di controllo includono nodi come `start``end`,`decision`,`fork`, e`join`.
AWS SCT converte i nodi di azione di origine e i nodi del flusso di controllo in AWS Step Functions. Nel AWS Step Functions, definisci i tuoi flussi di lavoro in Amazon States Language (ASL). AWS SCT utilizza ASL per definire la macchina a stati, che è una raccolta di stati che può funzionare, determinare a quali stati passare, interrompere con un errore e così via. Successivamente, AWS SCT carica i file JSON con le definizioni delle macchine a stati. Quindi, AWS SCT puoi utilizzare il tuo ruolo AWS Identity and Access Management (IAM) per configurare le tue macchine a stati. AWS Step Functions Per ulteriori informazioni, consulta [What is AWS Step Functions?](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html) nella *Guida per gli AWS Step Functions sviluppatori*.
Inoltre, AWS SCT crea un pacchetto di estensione con AWS Lambda funzioni che emulano le funzioni di origine che AWS Step Functions non supporta. Per ulteriori informazioni, consulta [Utilizzo dei pacchetti di estensione con AWS Schema Conversion Tool](CHAP_ExtensionPack.md).
AWS SCT migra le proprietà del lavoro di origine in. AWS Systems Manager Per memorizzare i nomi e i valori dei parametri, AWS SCT utilizza Parameter Store, una funzionalità di AWS Systems Manager. Per ulteriori informazioni, consulta [Cos'è AWS Systems Manager?](https://docs.aws.amazon.com/systems-manager/latest/userguide/what-is-systems-manager.html) nella *Guida AWS Systems Manager per l'utente*.
È possibile utilizzare AWS SCT per aggiornare automaticamente i valori e i nomi dei parametri. A causa delle differenze di architettura tra Apache Oozie e AWS Step Functions, potrebbe essere necessario configurare i parametri. AWS SCT può trovare il nome o il valore di un parametro specificato nei file sorgente e sostituirli con nuovi valori. Per ulteriori informazioni, consulta [Fase 3: Configurazione dei parametri](#big-data-oozie-configure-parameters).
L'immagine seguente mostra il diagramma dell'architettura della conversione di Apache Oozie a. AWS Step Functions
![\[Il diagramma dell'architettura della conversione di Apache Oozie a. AWS Step Functions\]](http://docs.aws.amazon.com/it_it/SchemaConversionTool/latest/userguide/images/aws-sct-oozie-conversion-architecture-diagram.png)
Per avviare la conversione, crea ed esegui lo script AWS SCT CLI. Questo script include il set completo di comandi per eseguire la conversione. È possibile scaricare e modificare un modello dello script di conversione Apache Oozie. Per ulteriori informazioni, consulta [Ottenere scenari CLI](CHAP_Reference.md#CHAP_Reference.Scenario).
Assicurati che lo script includa i seguenti passaggi.
## Fase 1: Connect ai servizi di origine e di destinazione
Per iniziare la conversione del tuo cluster Apache Oozie, crea un nuovo progetto. AWS SCT Successivamente, connettiti ai servizi di origine e di destinazione. Assicurati di creare e fornire AWS le risorse di destinazione prima di iniziare la migrazione. Per ulteriori informazioni, consulta [Prerequisiti per l'utilizzo di Apache Oozie come sorgente](CHAP_Source.Oozie.md#CHAP_Source.Oozie.Prerequisites).
In questo passaggio, si utilizzano i seguenti comandi AWS SCT CLI.
+ `CreateProject`— per creare un nuovo AWS SCT progetto.
+ `AddSource`— per aggiungere i file sorgente di Apache Oozie nel AWS SCT progetto.
+ `ConnectSource`— per connettersi ad Apache Oozie come sorgente.
+ `AddTarget`— da aggiungere AWS Step Functions come obiettivo di migrazione al progetto.
+ `ConnectTarget`— a cui connettersi AWS Step Functions.
Per esempi di utilizzo di questi comandi AWS SCT CLI, vedere. [Connessione ad Apache Oozie](CHAP_Source.Oozie.md)
Quando `ConnectTarget` esegui i comandi `ConnectSource` or, AWS SCT tenta di stabilire la connessione ai tuoi servizi. Se il tentativo di connessione fallisce, AWS SCT interrompe l'esecuzione dei comandi dallo script CLI e visualizza un messaggio di errore.
## Fase 2: Impostare le regole di mappatura
Dopo esserti connesso ai servizi di origine e di destinazione, configura le regole di mappatura. Una regola di mappatura definisce il target di migrazione per i flussi di lavoro e i parametri di Apache Oozie di origine. Per ulteriori informazioni sulle regole di mappatura, consulta. [Mappatura dei tipi di dati in AWS Schema Conversion Tool](CHAP_Mapping.md)
Per definire gli oggetti di origine e di destinazione per la conversione, utilizzate il `AddServerMapping` comando. Questo comando utilizza due parametri: `sourceTreePath` e`targetTreePath`. I valori di questi parametri includono un percorso esplicito verso gli oggetti di origine e di destinazione. Affinché Apache Oozie venga AWS Step Functions convertita, questi parametri devono iniziare con. `ETL`
Il seguente esempio di codice crea una regola di mappatura per `OOZIE` oggetti e. `AWS_STEP_FUNCTIONS` Hai aggiunto questi oggetti al AWS SCT progetto utilizzando `AddTarget` i comandi `AddSource` e nel passaggio precedente.
```
AddServerMapping
-sourceTreePath: 'ETL.APACHE_OOZIE'
-targetTreePath: 'ETL.AWS_STEP_FUNCTIONS'
/
```
Per ulteriori informazioni sul `AddServerMapping` comando, consulta la [AWS Schema Conversion Tool CLI Reference](https://s3.amazonaws.com/publicsctdownload/AWS+SCT+CLI+Reference.pdf).
## Fase 3: Configurazione dei parametri
Se i flussi di lavoro di Apache Oozie di origine utilizzano parametri, potrebbe essere necessario modificarne i valori dopo la conversione in. AWS Step Functions Inoltre, potresti dover aggiungere nuovi parametri da utilizzare con il tuo. AWS Step Functions
In questo passaggio, si utilizzano i `AddTargetParameter` comandi `AddParameterMapping` and.
Per sostituire i valori dei parametri nei file sorgente, utilizzate il `AddParameterMapping` comando. AWS SCT analizza i file sorgente, trova i parametri per nome o valore e ne modifica i valori. È possibile eseguire un solo comando per scansionare tutti i file sorgente. È possibile definire l'ambito dei file da scansionare utilizzando uno dei primi tre parametri del seguente elenco. Questo comando utilizza fino a sei parametri.
+ `filterName`— il nome del filtro per gli oggetti di origine. È possibile creare un filtro utilizzando il `CreateFilter` comando.
+ `treePath`— il percorso esplicito degli oggetti di origine.
+ `namePath`— il percorso esplicito di uno specifico oggetto di origine.
+ `sourceParameterName`— il nome del parametro di origine.
+ `sourceValue`— il valore del parametro di origine.
+ `targetValue`— il valore del parametro di destinazione.
Il seguente esempio di codice sostituisce tutti i parametri il cui valore è uguale `c:\oozie\hive.py` al `s3://bucket-oozie/hive.py` valore.
```
AddParameterMapping
-treePath: 'ETL.OOZIE.Applications'
-sourceValue: 'c:\oozie\hive.py'
-targetValue: 's3://bucket-oozie/hive.py'
/
```
Il seguente esempio di codice sostituisce tutti i parametri il cui nome è uguale `nameNode` al `hdfs://ip-111-222-33-44.eu-west-1.compute.internal:8020` valore.
```
AddParameterMapping
-treePath: 'ETL.OOZIE_SOURCE.Applications'
-sourceParameter: 'nameNode'
-targetValue: 'hdfs://ip-111-222-33-44.eu-west-1.compute.internal:8020'
/
```
Il seguente esempio di codice sostituisce tutti i parametri in cui il nome è uguale `nameNode` e il valore è uguale `hdfs://ip-55.eu-west-1.compute.internal:8020` al valore del `targetValue` parametro.
```
AddParameterMapping
-treePath: 'ETL.OOZIE_SOURCE.Applications'
-sourceParameter: 'nameNode'
-sourceValue: 'hdfs://ip-55-66-77-88.eu-west-1.compute.internal:8020'
-targetValue: 'hdfs://ip-111-222-33-44.eu-west-1.compute.internal:8020'
/
```
Per aggiungere un nuovo parametro nei file di destinazione oltre a un parametro esistente dai file di origine, utilizzate il `AddTargetParameter` comando. Questo comando utilizza lo stesso set di parametri del `AddParameterMapping` comando.
Il seguente esempio di codice aggiunge il parametro `clusterId` target anziché il `nameNode` parametro.
```
AddTargetParameter
-treePath: 'ETL.OOZIE_SOURCE.Applications'
-sourceParameter: 'nameNode'
-sourceValue: 'hdfs://ip-55-66-77-88.eu-west-1.compute.internal:8020'
-targetParameter: 'clusterId'
-targetValue: '1234567890abcdef0'
/
```
Per ulteriori informazioni sui `CreateFilter` comandi,, e`AddServerMapping`,,`AddParameterMapping`,`AddTargetParameter`,,,,, consulta la [AWS Schema Conversion Tool CLI Reference](https://s3.amazonaws.com/publicsctdownload/AWS+SCT+CLI+Reference.pdf).
## Fase 4: creazione di un report di valutazione
Prima di iniziare la conversione, ti consigliamo di creare un rapporto di valutazione. Questo rapporto riassume tutte le attività di migrazione e descrive in dettaglio le azioni che emergeranno durante la migrazione. Per assicurarti che la migrazione non vada a buon fine, visualizza questo rapporto e risolvi le azioni da intraprendere prima della migrazione. Per ulteriori informazioni, consulta [Report di valutazione](CHAP_AssessmentReport.md).
In questo passaggio, si utilizza il `CreateReport` comando. Questo comando utilizza due parametri. Il primo parametro descrive gli oggetti di origine per i quali AWS SCT crea un rapporto di valutazione. A tale scopo, utilizzate uno dei seguenti parametri: `filterName``treePath`, o`namePath`. Questo parametro è obbligatorio. Inoltre, è possibile aggiungere un parametro booleano opzionale. `forceLoad` Se impostate questo parametro su`true`, carica AWS SCT automaticamente tutti gli oggetti secondari per l'oggetto di origine specificato nel `CreateReport` comando.
Il seguente esempio di codice crea un rapporto di valutazione per il `Applications` nodo dei file Oozie di origine.
```
CreateReport
-treePath: 'ETL.APACHE_OOZIE.Applications'
/
```
È quindi possibile salvare una copia del rapporto di valutazione come file PDF o file con valori separati da virgole (CSV). A tale scopo, utilizzate il comando or. `SaveReportPDF` `SaveReportCSV`
Il `SaveReportPDF` comando salva una copia del rapporto di valutazione come file PDF. Questo comando utilizza quattro parametri. Il `file` parametro è obbligatorio, gli altri parametri sono opzionali.
+ `file`— il percorso del file PDF e il suo nome.
+ `filter`— il nome del filtro creato in precedenza per definire l'ambito degli oggetti di origine da migrare.
+ `treePath`— il percorso esplicito degli oggetti del database di origine per i quali salvate una copia del rapporto di valutazione.
+ `namePath`— il percorso che include solo i nomi degli oggetti di destinazione per i quali si salva una copia del rapporto di valutazione.
Il `SaveReportCSV` comando salva il rapporto di valutazione in file CSV. Questo comando utilizza quattro parametri. Il `directory` parametro è obbligatorio, gli altri parametri sono opzionali.
+ `directory`— il percorso della cartella in cui vengono AWS SCT salvati i file CSV.
+ `filter`— il nome del filtro creato in precedenza per definire l'ambito degli oggetti di origine da migrare.
+ `treePath`— il percorso esplicito degli oggetti del database di origine per i quali salvate una copia del rapporto di valutazione.
+ `namePath`— il percorso che include solo i nomi degli oggetti di destinazione per i quali si salva una copia del rapporto di valutazione.
Il seguente esempio di codice salva una copia del rapporto di valutazione nel `c:\sct\ar.pdf` file.
```
SaveReportPDF
-file:'c:\sct\ar.pdf'
/
```
Il seguente esempio di codice salva una copia del rapporto di valutazione come file CSV nella `c:\sct` cartella.
```
SaveReportCSV
-file:'c:\sct'
/
```
Per ulteriori informazioni sui `SaveReportCSV` comandi`CreateReport`, `SaveReportPDF` and, consulta la [AWS Schema Conversion Tool CLI Reference](https://s3.amazonaws.com/publicsctdownload/AWS+SCT+CLI+Reference.pdf).
## Passaggio 5: Convertite i flussi di lavoro di Apache Oozie in with AWS Step Functions AWS SCT
Dopo aver configurato il AWS SCT progetto, converti il codice sorgente e applicalo a. Cloud AWS
In questo passaggio, si utilizzano i `ApplyToTarget` comandi `Convert` `SaveOnS3``ConfigureStateMachine`,, e.
Il `Migrate` comando migra gli oggetti di origine nel cluster di destinazione. Questo comando utilizza quattro parametri. Assicurati di specificare il `treePath` parametro `filter` o. Gli altri parametri sono opzionali.
+ `filter`— il nome del filtro creato in precedenza per definire l'ambito degli oggetti di origine da migrare.
+ `namePath`— il percorso esplicito di uno specifico oggetto di origine.
+ `treePath`— il percorso esplicito degli oggetti del database di origine per i quali si salva una copia del rapporto di valutazione.
+ `forceLoad`— se impostato su`true`, carica AWS SCT automaticamente gli alberi di metadati del database durante la migrazione. Il valore predefinito è `false`.
Il seguente esempio di codice converte i file dalla `Applications` cartella nei file Oozie di origine.
```
Convert
-treePath: 'ETL.APACHE_OOZIE.Applications'
/
```
`SaveOnS3`carica le definizioni delle macchine a stati nel tuo bucket Amazon S3. Questo comando utilizza il parametro. `treePath` Per eseguire questo comando, utilizzate la cartella di destinazione con le definizioni delle macchine a stati come valore di questo parametro.
Quanto segue carica la `State machine definitions` cartella dell'oggetto di `AWS_STEP_FUNCTIONS` destinazione nel bucket Amazon S3. AWS SCT utilizza il bucket Amazon S3 che hai memorizzato nel profilo del AWS servizio durante la fase. [Prerequisiti](CHAP_Source.Oozie.md#CHAP_Source.Oozie.Prerequisites)
```
SaveOnS3
-treePath: 'ETL.AWS_STEP_FUNCTIONS.State machine definitions'
/
```
Il `ConfigureStateMachine` comando configura le macchine a stati. Questo comando utilizza fino a sei parametri. Assicuratevi di definire l'ambito di destinazione utilizzando uno dei primi tre parametri del seguente elenco.
+ `filterName`— il nome del filtro per gli oggetti di destinazione. È possibile creare un filtro utilizzando il `CreateFilter` comando.
+ `treePath`— il percorso esplicito degli oggetti di destinazione.
+ `namePath`— il percorso esplicito verso uno specifico oggetto di destinazione.
+ `iamRole`— l'Amazon Resource Name (ARN) del ruolo IAM che fornisce l'accesso alle macchine Step. Questo parametro è obbligatorio.
Il seguente esempio di codice configura le macchine a stati definite `AWS_STEP_FUNCTIONS` utilizzando il ruolo *role\$1name* IAM.
```
ConfigureStateMachine
-treePath: 'ETL.AWS_STEP_FUNCTIONS.State machine definitions'
-role: 'arn:aws:iam::555555555555:role/role_name'
/
```
Il `ApplyToTarget` comando applica il codice convertito al server di destinazione. Per eseguire questo comando, utilizzate uno dei seguenti parametri:`filterName`,`treePath`, o `namePath` per definire gli oggetti di destinazione da applicare.
Il seguente esempio di codice applica la macchina a `app_wp` stati a AWS Step Functions.
```
ApplyToTarget
-treePath: 'ETL.AWS_STEP_FUNCTIONS.State machines.app_wp'
/
```
Per assicurarti che il codice convertito produca gli stessi risultati del codice sorgente, puoi usare il pacchetto di AWS SCT estensione. Si tratta di un insieme di AWS Lambda funzioni che emulano le funzioni di Apache Oozie che AWS Step Functions non supporta. Per installare questo pacchetto di estensione, puoi usare il comando. `CreateLambdaExtPack`
Questo comando utilizza fino a cinque parametri. Assicurati di utilizzare **Oozie2SF** per`extPackId`. In questo caso, AWS SCT crea un pacchetto di estensione per le funzioni di origine di Apache Oozie.
+ `extPackId`— l'identificatore univoco per un set di funzioni Lambda. Questo parametro è obbligatorio.
+ `tempDirectory`— il percorso in cui è AWS SCT possibile archiviare i file temporanei. Questo parametro è obbligatorio.
+ `awsProfile`— il nome del tuo AWS profilo.
+ `lambdaExecRoles`— l'elenco di Amazon Resource Names (ARNs) dei ruoli di esecuzione da utilizzare per le funzioni Lambda.
+ `createInvokeRoleFlag`— il flag booleano che indica se creare un ruolo di esecuzione per. AWS Step Functions
Per installare e utilizzare il pacchetto di estensione, assicurati di fornire le autorizzazioni richieste. Per ulteriori informazioni, consulta [Autorizzazioni per l'utilizzo AWS Lambda delle funzioni nel pacchetto di estensione](CHAP_Source.Oozie.md#CHAP_Source.Oozie.TargetPrerequisites).
Per ulteriori informazioni sui `CreateLambdaExtPack` comandi`Convert`,,, e `SaveOnS3``ConfigureStateMachine`,,`ApplyToTarget`,, consulta la [AWS Schema Conversion Tool CLI Reference](https://s3.amazonaws.com/publicsctdownload/AWS+SCT+CLI+Reference.pdf).
## Esecuzione dello script CLI
Dopo aver finito di modificare lo script AWS SCT CLI, salvalo come file con estensione. `.scts` Ora puoi eseguire lo script dalla `app` cartella del percorso di AWS SCT installazione. A tale scopo, utilizzare il comando seguente.
```
RunSCTBatch.cmd --pathtoscts "C:\script_path\oozie.scts"
```
Nell'esempio precedente, sostituite *script\$1path* con il percorso del file con lo script CLI. Per ulteriori informazioni sull'esecuzione degli script CLI in AWS SCT, vedere. [Modalità script](CHAP_Reference.md#CHAP_Reference.ScriptMode)
## Nodi Apache Oozie in cui è possibile eseguire la conversione AWS SCT AWS Step Functions
Puoi utilizzarlo AWS SCT per convertire i nodi di azione e i nodi di flusso di controllo di Apache Oozie in. AWS Step Functions
I nodi di azione supportati includono i seguenti:
+ Azione Hive
+ Azione Hive2
+ Azione Spark
+ MapReduce Azione in streaming
+ Azione Java
+ DistCp azione
+ Azione suina
+ Azione Sqoop
+ Azione FS
+ Azione Shell
I nodi del flusso di controllo supportati includono quanto segue:
+ Inizia l'azione
+ Termina azione
+ Azione di morte
+ Azione decisionale
+ Azione della forcella
+ Azione congiunta