As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Convertendo fluxos de trabalho do Oozie em com AWS Step Functions AWS Schema Conversion Tool
Para converter fluxos de trabalho do Apache Oozie, certifique-se de usar a AWS SCT versão 1.0.671 ou superior. Além disso, familiarize-se com a interface de linha de comandos (CLI) da AWS SCT. Para obter mais informações, consulte [Referência CLI para AWS Schema Conversion Tool](CHAP_Reference.md).
**Topics**
+ [Visão geral da conversão](#big-data-oozie-overview)
+ [Etapa 1: conectar-se aos seus serviços de origem e destino](#big-data-oozie-connect-to-databases)
+ [Etapa 2: configurar as regras de mapeamento](#big-data-oozie-mapping-rules)
+ [Etapa 3: configurar parâmetros](#big-data-oozie-configure-parameters)
+ [Etapa 4: criar um relatório de avaliação](#big-data-oozie-assessment-report)
+ [Etapa 5: Converta seus fluxos de trabalho do Apache Oozie em com AWS Step Functions AWS SCT](#big-data-oozie-migrate)
+ [Como executar seu script de CLI](#big-data-oozie-run-migration)
+ [Nodos Apache Oozie que AWS SCT podem ser convertidos em AWS Step Functions](#big-data-oozie-supported-nodes)
## Visão geral da conversão
Seu código fonte do Apache Oozie inclui nós de ação, nós de fluxo de controle e propriedades do trabalho. Os nós de ação definem as tarefas que você executa em seu fluxo de trabalho do Apache Oozie. Quando você usa o Apache Oozie para orquestrar seu cluster do Apache Hadoop, um nó de ação inclui uma tarefa do Hadoop. Os nós de controle de fluxo fornecem um mecanismo para controlar o caminho do fluxo de trabalho. Os nós do fluxo de controle incluem nós como `start`, `end`, `decision`, `fork` e `join`.
AWS SCT converte seus nós de ação de origem e nós de fluxo de controle em AWS Step Functions. Em AWS Step Functions, você define seus fluxos de trabalho na Amazon States Language (ASL). AWS SCT usa ASL para definir sua máquina de estados, que é uma coleção de estados que pode funcionar, determinar para quais estados fazer a transição a seguir, parar com um erro e assim por diante. Em seguida, AWS SCT carrega os arquivos JSON com as definições das máquinas de estado. Em seguida, AWS SCT pode usar sua função AWS Identity and Access Management (IAM) para configurar suas máquinas de estado em AWS Step Functions. Para obter mais informações, consulte [O que é AWS Step Functions?](https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html) no *Guia do AWS Step Functions desenvolvedor*.
Além disso, AWS SCT cria um pacote de extensão com AWS Lambda funções que emulam as funções de origem que AWS Step Functions não são suportadas. Para obter mais informações, consulte [Usando pacotes de extensão com AWS Schema Conversion Tool](CHAP_ExtensionPack.md).
AWS SCT migra suas propriedades de trabalho de origem para o. AWS Systems Manager Para armazenar nomes e valores de parâmetros, AWS SCT usa Parameter Store, um recurso de AWS Systems Manager. Para obter mais informações, consulte [O que é AWS Systems Manager?](https://docs.aws.amazon.com/systems-manager/latest/userguide/what-is-systems-manager.html) no *Guia do AWS Systems Manager usuário*.
Você pode usar AWS SCT para atualizar automaticamente os valores e os nomes dos seus parâmetros. Devido às diferenças de arquitetura entre o Apache Oozie e AWS Step Functions, talvez seja necessário configurar seus parâmetros. AWS SCT pode encontrar um nome ou valor de parâmetro especificado em seus arquivos de origem e substituí-los por novos valores. Para obter mais informações, consulte [Etapa 3: configurar parâmetros](#big-data-oozie-configure-parameters).
A imagem a seguir mostra o diagrama de arquitetura da conversão do Apache Oozie para. AWS Step Functions
Para iniciar a conversão, crie e execute seu script de AWS SCT CLI. Esse script inclui o conjunto completo de comandos para executar a conversão. Você pode baixar e editar um modelo do script de conversão do Apache Oozie. Para obter mais informações, consulte [Obter cenários de CLI](CHAP_Reference.md#CHAP_Reference.Scenario).
Verifique se o script inclui as seguintes etapas.
## Etapa 1: conectar-se aos seus serviços de origem e destino
Para iniciar a conversão do seu cluster Apache Oozie, crie um novo AWS SCT projeto. Em seguida, conecte-se aos seus serviços de origem e destino. Certifique-se de criar e provisionar seus AWS recursos de destino antes de iniciar a migração. Para obter mais informações, consulte [Pré-requisitos de uso do Apache Oozie como origem](CHAP_Source.Oozie.md#CHAP_Source.Oozie.Prerequisites).
Nesta etapa, você usa os seguintes comandos da AWS SCT CLI.
+ `CreateProject`— para criar um novo AWS SCT projeto.
+ `AddSource`: para adicionar seus arquivos Apache Oozie de origem em seu projeto da AWS SCT .
+ `ConnectSource`: para conectar-se ao Apache Oozie como origem.
+ `AddTarget`— para adicionar AWS Step Functions como alvo de migração em seu projeto.
+ `ConnectTarget`: Para conectar-se ao AWS Step Functions.
Para obter exemplos de uso desses comandos da AWS SCT CLI, consulte. [Como se conectar ao Apache Oozie](CHAP_Source.Oozie.md)
Quando você executa `ConnectTarget` os comandos `ConnectSource` ou, AWS SCT tenta estabelecer a conexão com seus serviços. Se a tentativa de conexão falhar, AWS SCT interrompe a execução dos comandos do script da CLI e exibirá uma mensagem de erro.
## Etapa 2: configurar as regras de mapeamento
Depois de se conectar aos serviços de origem e de destino, configure as regras de mapeamento. Uma regra de mapeamento define a meta de migração para seus fluxos de trabalho e parâmetros de origem do Apache Oozie. Para obter mais informações sobre regras de mapeamento, consulte [Mapear tipo de dados no AWS Schema Conversion Tool](CHAP_Mapping.md).
Para definir objetos de origem e destino para conversão, use o comando `AddServerMapping`. Esse comando usa dois parâmetros: `sourceTreePath` e `targetTreePath`. Os valores desses parâmetros incluem um caminho explícito para seus objetos de origem e destino. Para que o Apache Oozie faça a conversão do AWS Step Functions , esses parâmetros devem começar com `ETL`.
O exemplo de código a seguir cria uma regra de mapeamento para os objetos `OOZIE` e `AWS_STEP_FUNCTIONS`. Você adicionou esses objetos ao seu AWS SCT projeto usando `AddSource` `AddTarget` comandos na etapa anterior.
```
AddServerMapping
-sourceTreePath: 'ETL.APACHE_OOZIE'
-targetTreePath: 'ETL.AWS_STEP_FUNCTIONS'
/
```
Para obter mais informações sobre o comando `AddServerMapping`, consulte [Referência da CLI do AWS Schema Conversion Tool](https://s3.amazonaws.com/publicsctdownload/AWS+SCT+CLI+Reference.pdf).
## Etapa 3: configurar parâmetros
Se seus fluxos de trabalho de origem do Apache Oozie usarem parâmetros, talvez seja necessário alterar seus valores após a conversão para o AWS Step Functions. Além disso, talvez seja necessário adicionar novos parâmetros para usar com seu AWS Step Functions.
Para esta etapa, use os comandos `AddParameterMapping` e `AddTargetParameter`.
Para substituir os valores dos parâmetros em seus arquivos de origem, use o comando `AddParameterMapping`. A AWS SCT verifica seus arquivos de origem, encontra os parâmetros por nome ou valor e altera seus valores. Você pode executar um único comando para verificar todos os seus arquivos de origem. Você define o escopo dos arquivos a serem examinados usando um dos três primeiros parâmetros da lista a seguir. Esse comando usa até seis parâmetros.
+ `filterName`: o nome do filtro para seus objetos de origem. Você pode criar um filtro usando o comando `CreateFilter`.
+ `treePath`: o caminho explícito para os objetos de origem.
+ `namePath`: o caminho explícito para um objeto específico de origem.
+ `sourceParameterName`: o nome do seu parâmetro de origem.
+ `sourceValue`: o valor do seu parâmetro de origem.
+ `targetValue`: o nome do seu parâmetro de destino.
O exemplo de código a seguir substitui todos os parâmetros em que o valor é igual a `c:\oozie\hive.py` com o valor `s3://bucket-oozie/hive.py`.
```
AddParameterMapping
-treePath: 'ETL.OOZIE.Applications'
-sourceValue: 'c:\oozie\hive.py'
-targetValue: 's3://bucket-oozie/hive.py'
/
```
O exemplo de código a seguir substitui todos os parâmetros em que o nome é igual a `nameNode` com o valor `hdfs://ip-111-222-33-44.eu-west-1.compute.internal:8020`.
```
AddParameterMapping
-treePath: 'ETL.OOZIE_SOURCE.Applications'
-sourceParameter: 'nameNode'
-targetValue: 'hdfs://ip-111-222-33-44.eu-west-1.compute.internal:8020'
/
```
O exemplo de código a seguir substitui todos os parâmetros em que o nome é igual a `nameNode` e o valor é igual a `hdfs://ip-55.eu-west-1.compute.internal:8020` com o valor do parâmetro `targetValue`.
```
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'
/
```
Para adicionar um novo parâmetro nos arquivos de destino, além de um parâmetro existente nos arquivos de origem, use o comando `AddTargetParameter`. Esse comando usa o mesmo conjunto de parâmetros do comando `AddParameterMapping`.
O exemplo de código a seguir adiciona o parâmetro de destino `clusterId` em vez do parâmetro `nameNode`.
```
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'
/
```
Para obter mais informações sobre os comandos `AddServerMapping`, `AddParameterMapping`, `AddTargetParameter` e `CreateFilter`, consulte a [Referência da CLI da AWS Schema Conversion Tool](https://s3.amazonaws.com/publicsctdownload/AWS+SCT+CLI+Reference.pdf).
## Etapa 4: criar um relatório de avaliação
Antes de iniciar a conversão, recomendamos criar um relatório de avaliação. Esse relatório resume todas as tarefas de migração e detalha os itens de ação que surgirão durante a migração. Para garantir que sua migração não falhe, visualize esse relatório e aborde os itens de ação antes da migração. Para obter mais informações, consulte [Relatório de avaliação da ](CHAP_AssessmentReport.md).
Para esta etapa, use o comando `CreateReport`. Esse comando usa dois parâmetros. O primeiro parâmetro descreve os objetos de origem para os quais AWS SCT cria um relatório de avaliação. Para fazer isso, utilize um dos seguintes parâmetros: `filterName`, `treePath` ou `namePath`. Esse parâmetro é obrigatório. Além disso, você pode adicionar um parâmetro booleano opcional `forceLoad`. Se você definir esse parâmetro como`true`, carregará AWS SCT automaticamente todos os objetos secundários do objeto de origem que você especificar no `CreateReport` comando.
O exemplo de código a seguir cria um relatório de avaliação para o nó `Applications` dos seus arquivos Oozie de origem.
```
CreateReport
-treePath: 'ETL.APACHE_OOZIE.Applications'
/
```
Você pode então salvar uma cópia do relatório de avaliação como um arquivo PDF ou arquivos de valores separados por vírgula (CSV). Para isso, use o comando `SaveReportPDF` ou `SaveReportCSV`.
O comando `SaveReportPDF` salva uma cópia do seu relatório de avaliação como um arquivo PDF. Esse comando usa quatro parâmetros. O parâmetro `file` é obrigatório, outros parâmetros são opcionais.
+ `file`: o caminho para o arquivo PDF e seu nome.
+ `filter`: o nome do filtro que você criou antes para definir o escopo dos objetos de origem a serem migrados.
+ `treePath`: o caminho explícito para os objetos do banco de dados de origem para os quais você salva uma cópia do relatório de avaliação.
+ `namePath`: o caminho que inclui somente os nomes dos objetos de destino para os quais você salva uma cópia do relatório de avaliação.
O comando `SaveReportCSV` salva seu relatório de avaliação em arquivos CSV. Esse comando usa quatro parâmetros. O parâmetro `directory` é obrigatório, outros parâmetros são opcionais.
+ `directory`— o caminho para a pasta em que os arquivos CSV são AWS SCT salvos.
+ `filter`: o nome do filtro que você criou antes para definir o escopo dos objetos de origem a serem migrados.
+ `treePath`: o caminho explícito para os objetos do banco de dados de origem para os quais você salva uma cópia do relatório de avaliação.
+ `namePath`: o caminho que inclui somente os nomes dos objetos de destino para os quais você salva uma cópia do relatório de avaliação.
O exemplo de código a seguir salva uma cópia do seu relatório de avaliação no arquivo `c:\sct\ar.pdf`.
```
SaveReportPDF
-file:'c:\sct\ar.pdf'
/
```
O exemplo de código a seguir salva uma cópia do seu relatório de avaliação como arquivos CSV na pasta `c:\sct`.
```
SaveReportCSV
-file:'c:\sct'
/
```
Para obter mais informações sobre os comandos `CreateReport`, `SaveReportPDF` e `SaveReportCSV`, consulte a [Referência da CLI da AWS Schema Conversion Tool](https://s3.amazonaws.com/publicsctdownload/AWS+SCT+CLI+Reference.pdf).
## Etapa 5: Converta seus fluxos de trabalho do Apache Oozie em com AWS Step Functions AWS SCT
Depois de configurar seu AWS SCT projeto, converta seu código-fonte e aplique-o ao Nuvem AWS.
Para esta etapa, use os comandos `Convert`, `SaveOnS3`, `ConfigureStateMachine` e `ApplyToTarget`.
O comando `Migrate` migra seus objetos de origem para o cluster de destino. Esse comando usa quatro parâmetros. Certifique-se de especificar o parâmetro `filter` ou `treePath`. Outros parâmetros são opcionais.
+ `filter`: o nome do filtro que você criou antes para definir o escopo dos objetos de origem a serem migrados.
+ `namePath`: o caminho explícito para um objeto específico de origem.
+ `treePath`: o caminho explícito para os objetos do banco de dados de origem para os quais você salva uma cópia do relatório de avaliação.
+ `forceLoad`— quando definido como`true`, carrega AWS SCT automaticamente as árvores de metadados do banco de dados durante a migração. O valor padrão é `false`.
O exemplo de código a seguir converte arquivos da pasta `Applications` em seus arquivos Oozie de origem.
```
Convert
-treePath: 'ETL.APACHE_OOZIE.Applications'
/
```
O `SaveOnS3` carrega as definições de estado das máquinas para o seu bucket do Amazon S3. Esse comando usa o parâmetro `treePath`. Para executar esse comando, use a pasta de destino com definições de máquinas de estado como o valor desse parâmetro.
O seguinte carrega a `State machine definitions` pasta do seu objeto de `AWS_STEP_FUNCTIONS` destino no bucket do Amazon S3. AWS SCT usa o bucket do Amazon S3 que você armazenou no perfil AWS de serviço na [Pré-requisitos](CHAP_Source.Oozie.md#CHAP_Source.Oozie.Prerequisites) etapa.
```
SaveOnS3
-treePath: 'ETL.AWS_STEP_FUNCTIONS.State machine definitions'
/
```
O comando `ConfigureStateMachine` configura as máquinas de estado. Esse comando usa até seis parâmetros. Certifique-se de definir o escopo de destino usando um dos três primeiros parâmetros da lista a seguir.
+ `filterName`: o nome do filtro para seus objetos de destino. Você pode criar um filtro usando o comando `CreateFilter`.
+ `treePath`: o caminho explícito para os objetos de destino.
+ `namePath`: o caminho explícito para um objeto específico de destino.
+ `iamRole`: o nome do recurso da Amazon (ARN) do perfil do IAM que fornece acesso às suas máquinas de etapa. Esse parâmetro é obrigatório.
O exemplo de código a seguir configura as máquinas de estado definidas no `AWS_STEP_FUNCTIONS` uso da função do {{role\_name}} IAM.
```
ConfigureStateMachine
-treePath: 'ETL.AWS_STEP_FUNCTIONS.State machine definitions'
-role: 'arn:aws:iam::555555555555:role/{{role_name}}'
/
```
O comando `ApplyToTarget` aplica seu código convertido ao servidor de destino. Para executar esse comando, use um dos seguintes parâmetros: `filterName`, `treePath` ou `namePath` para definir os objetos de destino a serem aplicados.
O exemplo de código a seguir aplica a máquina de `app_wp` estado AWS Step Functions a.
```
ApplyToTarget
-treePath: 'ETL.AWS_STEP_FUNCTIONS.State machines.app_wp'
/
```
Para garantir que seu código convertido produza os mesmos resultados que seu código fonte, você pode usar o pacote de extensão AWS SCT . Este é um conjunto de AWS Lambda funções que emulam suas funções do Apache Oozie que AWS Step Functions não suportam. Para instalar esse pacote de extensão, você pode usar o comando `CreateLambdaExtPack`.
Esse comando usa até cinco parâmetros. Certifique-se de usar o **Oozie2SF** para `extPackId`. Nesse caso, AWS SCT cria um pacote de extensão para as funções de origem do Apache Oozie.
+ `extPackId`: o identificador exclusivo para um conjunto de funções do Lambda. Esse parâmetro é obrigatório.
+ `tempDirectory`— o caminho onde AWS SCT pode armazenar arquivos temporários. Esse parâmetro é obrigatório.
+ `awsProfile`— o nome do seu AWS perfil.
+ `lambdaExecRoles`— a lista de nomes de recursos da Amazon (ARNs) das funções de execução a serem usadas para funções Lambda.
+ `createInvokeRoleFlag`: o sinalizador booleano que indica se uma função de execução deve ser criada para AWS Step Functions.
Para instalar e usar o pacote de extensão, verifique se você fornece as permissões necessárias. Para obter mais informações, consulte [Permissões para usar AWS Lambda funções no pacote de extensões](CHAP_Source.Oozie.md#CHAP_Source.Oozie.TargetPrerequisites).
Para obter mais informações sobre os comandos `Convert`, `SaveOnS3`, `ConfigureStateMachine`, `ApplyToTarget` e `CreateLambdaExtPack`, consulte a [Referência da CLI da AWS Schema Conversion Tool](https://s3.amazonaws.com/publicsctdownload/AWS+SCT+CLI+Reference.pdf).
## Como executar seu script de CLI
Depois de terminar de editar seu script de AWS SCT CLI, salve-o como um arquivo com a `.scts` extensão. Agora, você pode executar seu script a partir da `app` pasta do caminho de AWS SCT instalação. Para fazer isso, use o comando a seguir.
```
RunSCTBatch.cmd --pathtoscts "C:\{{script_path}}\oozie.scts"
```
No exemplo anterior, {{script\_path}} substitua pelo caminho do seu arquivo pelo script CLI. Para obter mais informações sobre a execução de scripts de CLI em AWS SCT, consulte. [Modo de script](CHAP_Reference.md#CHAP_Reference.ScriptMode)
## Nodos Apache Oozie que AWS SCT podem ser convertidos em AWS Step Functions
Você pode usar AWS SCT para converter nós de ação e nós de fluxo de controle do Apache Oozie em. AWS Step Functions
Os nós de ação suportados são os seguintes:
+ Ação Hive
+ Ação Hive2
+ Ação Spark
+ MapReduce Ação de streaming
+ Ação Java
+ DistCp ação
+ Ação Pig
+ Ação Sqoop
+ Ação FS
+ Ação Shell
Os nós de fluxo de controle suportados incluem o seguinte:
+ Ação de iniciar
+ Ação de encerrar
+ Ação de eliminar
+ Ação de decisão
+ Ação de garfo
+ Ação de junção