AWS Data Pipeline não está mais disponível para novos clientes. Os clientes existentes do AWS Data Pipeline podem continuar usando o serviço normalmente. [Saiba mais](https://aws.amazon.com/blogs/big-data/migrate-workloads-from-aws-data-pipeline/)
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á.
# Trabalhar com o Task Runner
O Task Runner é um aplicativo de agente de tarefas que pesquisa AWS Data Pipeline tarefas agendadas e as executa em instâncias do Amazon EC2, clusters do Amazon EMR ou outros recursos computacionais, relatando o status à medida que o faz. Dependendo do seu aplicativo, você pode optar pelo seguinte:
+ Permita AWS Data Pipeline instalar e gerenciar um ou mais aplicativos do Task Runner para você. Quando um pipeline é ativado, o padrão `Ec2Instance` ou `EmrCluster` objeto referenciado por um campo runsOn de atividade é criado automaticamente. AWS Data Pipeline cuida da instalação do Task Runner em uma instância do EC2 ou no nó principal de um cluster do EMR. Nesse padrão, AWS Data Pipeline pode fazer a maior parte do gerenciamento de instâncias ou clusters para você.
+ Executar todo o pipeline ou partes dele nos recursos que você gerencia. Os recursos potenciais incluem uma instância do Amazon EC2 de longa duração, um cluster do Amazon EMR ou um servidor físico. Você pode instalar um executor de tarefas (que pode ser o Executor de Tarefas ou um agente de tarefas personalizado de sua autoria) praticamente em qualquer lugar, desde que ele possa se comunicar com o AWS Data Pipeline serviço web. Neste padrão, você tem controle quase completo sobre quais recursos são usados e como eles são gerenciados. Além disso, é necessário instalar e configurar o Task Runner manualmente. Para fazer isso, siga os procedimentos desta seção, conforme descrito em [Executar trabalho em recursos existentes usando o Task Runner](dp-how-task-runner-user-managed.md).
# Executor de tarefas em recursos AWS Data Pipeline gerenciados
Quando um recurso é iniciado e gerenciado pelo AWS Data Pipeline, o serviço web instala automaticamente o Task Runner nesse recurso para processar tarefas no pipeline. Você especifica um recurso computacional (uma instância do Amazon EC2 ou um cluster do Amazon EMR) para o campo `runsOn` de um objeto de atividade. Ao iniciar esse recurso, o AWS Data Pipeline instala o Task Runner nele e o configura para processar todos os objetos de atividade cujo campo de `runsOn` esteja definido para ele. Quando o recurso é AWS Data Pipeline encerrado, os logs do Task Runner são publicados em um local do Amazon S3 antes de serem encerrados.
![\[Ciclo de vida do executor de tarefas em um recurso AWS Data Pipeline gerenciado\]](http://docs.aws.amazon.com/pt_br/datapipeline/latest/DeveloperGuide/images/dp-task-runner-managed-emr-jobflow.png)
Por exemplo, se você usar o `EmrActivity` em um pipeline e especificar um recurso `EmrCluster` no campo `runsOn`. Quando AWS Data Pipeline processa essa atividade, ele inicia um cluster do Amazon EMR e instala o Task Runner no nó principal. Em seguida, esse Task Runner processa as tarefas para atividades que têm o campo de `runsOn` definido para o objeto `EmrCluster`. O trecho a seguir de uma definição de pipeline mostra essa relação entre os dois objetos.
```
{
"id" : "MyEmrActivity",
"name" : "Work to perform on my data",
"type" : "EmrActivity",
"runsOn" : {"ref" : "MyEmrCluster"},
"preStepCommand" : "scp remoteFiles localFiles",
"step" : "s3://amzn-s3-demo-bucket/myPath/myStep.jar,firstArg,secondArg",
"step" : "s3://amzn-s3-demo-bucket/myPath/myOtherStep.jar,anotherArg",
"postStepCommand" : "scp localFiles remoteFiles",
"input" : {"ref" : "MyS3Input"},
"output" : {"ref" : "MyS3Output"}
},
{
"id" : "MyEmrCluster",
"name" : "EMR cluster to perform the work",
"type" : "EmrCluster",
"hadoopVersion" : "0.20",
"keypair" : "myKeyPair",
"masterInstanceType" : "m1.xlarge",
"coreInstanceType" : "m1.small",
"coreInstanceCount" : "10",
"taskInstanceType" : "m1.small",
"taskInstanceCount": "10",
"bootstrapAction" : "s3://elasticmapreduce/libs/ba/configure-hadoop,arg1,arg2,arg3",
"bootstrapAction" : "s3://elasticmapreduce/libs/ba/configure-other-stuff,arg1,arg2"
}
```
Para obter mais informações e exemplos sobre como executar essa atividade, consulte [EmrActivity](dp-object-emractivity.md).
Se você tiver vários recursos AWS Data Pipeline gerenciados em um pipeline, o Task Runner será instalado em cada um deles e todos pesquisarão as tarefas a serem AWS Data Pipeline processadas.
# Executar trabalho em recursos existentes usando o Task Runner
É possível instalar o Task Runner em recursos computacionais que você gerencia, como uma instância do Amazon EC2, um servidor físico ou uma estação de trabalho. O Task Runner pode ser instalado em qualquer lugar, em qualquer hardware ou sistema operacional compatível, desde que possa se comunicar com o serviço AWS Data Pipeline web.
Essa abordagem pode ser útil quando, por exemplo, você deseja usar AWS Data Pipeline para processar dados armazenados no firewall da sua organização. Ao instalar o Task Runner em um servidor na rede local, você pode acessar o banco de dados local com segurança e, em seguida, pesquisar AWS Data Pipeline a próxima tarefa a ser executada. Quando AWS Data Pipeline termina o processamento ou exclui o pipeline, a instância do Task Runner permanece em execução no seu recurso computacional até que você a desligue manualmente. Os logs do Task Runner são mantidos depois que a execução do pipeline é concluída.
Para usar o Task Runner em um recurso que você gerencia, é necessário fazer download do Task Runner e instalá-lo no seu recurso computacional, seguindo os procedimentos nesta seção.
**nota**
Você só pode instalar o Task Runner no Linux, UNIX ou macOS. O Task Runner não é compatível com o sistema operacional Windows.
Para usar o Task Runner 2.0, a versão mínima necessária do Java é 1.7.
Para conectar um Task Runner que você instalou às atividades do pipeline que devem ser processadas, adicione um campo de `workerGroup` ao objeto e configure o Task Runner para pesquisar o valor do grupo desse operador. É possível fazer isso especificando a string do grupo do operador como um parâmetro (por exemplo, `--workerGroup=wg-12345`) ao executar o arquivo JAR do Task Runner.
![\[AWS Data Pipeline diagram showing monthly task flow for archiving processed invoices using Task Runner.\]](http://docs.aws.amazon.com/pt_br/datapipeline/latest/DeveloperGuide/images/dp-task-runner-user-emr-jobflow.png)
```
{
"id" : "CreateDirectory",
"type" : "ShellCommandActivity",
"workerGroup" : "wg-12345",
"command" : "mkdir new-directory"
}
```
## Instalando o Task Runner
Esta seção explica como instalar e configurar o Task Runner e quais são os pré-requisitos. A instalação é um processo manual simples.
**Para instalar o Task Runner**
1. O Task Runner requer Java versões 1.6 ou 1.8. Para determinar se o Java está instalado e qual versão está sendo executada, use o seguinte comando:
```
java -version
```
Se você não tiver o Java 1.6 ou 1.8 instalado em seu computador, baixe uma dessas versões em [http://www.oracle. com/technetwork/java/index.html](http://www.oracle.com/technetwork/java/index.html). Faça download e instale o Java. Em seguida, vá para a próxima etapa.
1. Faça o download `TaskRunner-1.0.jar` de [https://s3.amazonaws.com/datapipeline-us-east-1/us-east-1/ software/latest/TaskRunner/TaskRunner -1.0.jar](https://s3.amazonaws.com/datapipeline-us-east-1/us-east-1/software/latest/TaskRunner/TaskRunner-1.0.jar) e copie-o em uma pasta no recurso de computação de destino. Para clusters do Amazon EMR que executam tarefas de `EmrActivity`, é necessário instalar o Task Runner no nó principal do cluster.
1. Ao usar o Task Runner para se conectar ao serviço AWS Data Pipeline web para processar seus comandos, os usuários precisam de acesso programático a uma função que tenha permissões para criar ou gerenciar pipelines de dados. Para obter mais informações, consulte [Conceder acesso programático](dp-get-setup.md#dp-grant-programmatic-access).
1. O Task Runner se conecta ao serviço AWS Data Pipeline web usando HTTPS. Se você estiver usando um AWS recurso, verifique se o HTTPS está habilitado na tabela de roteamento e na ACL de sub-rede apropriadas. Se você estiver usando um firewall ou proxy, verifique se a porta 443 está aberta.
# (Opcional) Conceder acesso ao Task Runner para o Amazon RDS
Com o Amazon RDS é possível controlar o acesso às suas instâncias de banco de dados usando grupos de segurança de banco de dados. Um security group de banco de dados funciona como um firewall controlando o acesso da rede à sua Instância de banco de dados. Por padrão, o acesso à rede é desativado nas suas instâncias de banco de dados. Você precisa modificar seus grupos de segurança de banco de dados para que o consiga acessar suas instâncias do Amazon RDS. O Task Runner recebe acesso ao Amazon RDS a partir da instância em que é executado. Assim, as contas e os security groups que você adicionar à sua instância do Amazon RDS dependerão de onde você instalou e o Task Runner.
**Para conceder acesso ao Task Runner no EC2-Classic**
1. Abra o console do Amazon RDS.
1. No painel de navegação, selecione ** Instances** e selecione sua instância de banco de dados.
1. Em **Security and Network**, selecione o security group. A página **Security Groups** é exibida com esse security group de banco de dados selecionado. Selecione o ícone de detalhes do security group de banco de dados.
1. Em **Security Group Details**, crie uma regra com **Connection Type** e **Details** apropriados. Esses campos dependem de onde o Task Runner está sendo executado, como descrito aqui:
+ `Ec2Resource`
+ **Connection Type**: `EC2 Security Group`
**Detalhes**: *my-security-group-name* (o nome do grupo de segurança que você criou para a instância do EC2)
+ `EmrResource`
+ **Connection Type**: `EC2 Security Group`
**Detalhes**: `ElasticMapReduce-master`
+ **Connection Type**: `EC2 Security Group`
**Detalhes**: `ElasticMapReduce-slave`
+ Seu ambiente local (on-premises)
+ **Connection Type**: `CIDR/IP`:
**Detalhes**: *my-ip-address* (o endereço IP do seu computador ou o intervalo de endereços IP da sua rede, se o computador estiver protegido por um firewall)
1. Clique em Add (Adicionar).
**Para conceder acesso ao Task Runner na EC2-VPC**
1. Abra o console do Amazon RDS.
1. No painel de navegação, escolha **Instâncias**.
1. Selecione o ícone de detalhes da instância de banco de dados. Em **Segurança e rede**, abra o link do grupo de segurança. Isso direciona você ao console do Amazon EC2. Se você estiver usando o design antigo do console para security groups, mude para o novo design selecionando o ícone exibido na parte superior da página do console.
1. Na guia **Entrada**, selecione **Editar**, **Adicionar regra**. Especifique a porta do banco de dados que você usou quando iniciou a instância do banco de dados. A origem depende de onde o Task Runner está sendo executado, como descrito aqui:
+ `Ec2Resource`
+ *my-security-group-id*(o ID do grupo de segurança que você criou para a instância do EC2)
+ `EmrResource`
+ *master-security-group-id*(o ID do grupo `ElasticMapReduce-master` de segurança)
+ *slave-security-group-id*(o ID do grupo `ElasticMapReduce-slave` de segurança)
+ Seu ambiente local (on-premises)
+ *ip-address*(o endereço IP do seu computador ou o intervalo de endereços IP da sua rede, se o computador estiver protegido por um firewall)
1. Clique em **Salvar**.
## Iniciar o Task Runner
Em uma nova janela de prompt de comando configurada para o diretório em que você instalou o Task Runner, inicie o Task Runner com o comando a seguir.
```
java -jar TaskRunner-1.0.jar --config ~/credentials.json --workerGroup=myWorkerGroup --region=MyRegion --logUri=s3://amzn-s3-demo-bucket/foldername
```
A opção `--config` aponta para o arquivo de credenciais.
A opção `--workerGroup` especifica o nome do grupo do operador, que deve ser o mesmo valor especificado no seu pipeline para que tarefas sejam processadas.
A opção `--region` especifica a região de serviço de onde as tarefas serão retiradas para execução.
A opção `--logUri` é usada para enviar seus logs compactados para um local no Amazon S3.
Quando o Task Runner está ativo, ele imprime o caminho do local onde os arquivos de log serão gravados na janela do terminal. Veja um exemplo do a seguir:
```
Logging to /Computer_Name/.../output/logs
```
O Task Runner deve ser executado separadamente do seu shell de login. Se você estiver usando um aplicativo de terminal para se conectar ao seu computador, precisará de um utilitário, como o nohup, ou uma tela para impedir que a aplicação Task Runner seja encerrada quando você se desconectar. Para obter mais informações sobre as opções de linha de comando, consulte [Opções de configuração do Task Runner](dp-taskrunner-config-options.md).
## Verificando o registro do Task Runner
A maneira mais fácil de saber se o Task Runner está funcionando é verificar se ele está gravando arquivos de log. De hora em hora, o Task Runner grava arquivos de log no diretório, `output/logs`, sob o diretório em que ele está instalado. O nome do arquivo é `Task Runner.log.YYYY-MM-DD-HH`, e HH vai de 00 a 23, em UDT. Para economizar espaço de armazenamento, todos os arquivos de log com mais de oito horas são compactados com GZip.
# Threads e pré-condições do Task Runner
O Task Runner usa um grupo de threads para cada uma das tarefas, atividades e precondições. A configuração padrão para `--tasks` é 2, o que significa que há dois threads alocados do pool de tarefas e cada thread pesquisa o AWS Data Pipeline serviço em busca de novas tarefas. Desse modo, `--tasks` é um atributo de ajuste de desempenho que pode ser usado para ajudar a otimizar o throughput do pipeline.
A lógica de nova tentativa do pipeline para precondições ocorre no Task Runner. Dois segmentos de pré-condição são alocados para pesquisar objetos de pré-condição. AWS Data Pipeline O Task Runner atende aos campos **retryDelay** e **preconditionTimeout** de objeto de pré-condição definidos por você nas pré-condições.
Em muitos casos, diminuir o tempo limite da pesquisa de precondição e o número de novas tentativas ajuda a melhorar o desempenho do seu aplicativo. Da mesma forma, os aplicativos com precondições prolongadas podem precisar ter o tempo limite e os valores de novas tentativas aumentados. Para obter mais informações objetos de precondição, consulte [Precondições](dp-concepts-preconditions.md).
# Opções de configuração do Task Runner
Estas são as opções de configuração disponíveis na linha de comando quando você inicia o Task Runner.
****
| Parâmetro da linha de comando | Description |
| --- | --- |
| `--help` | Ajuda da linha de comando. Exemplo: `Java -jar TaskRunner-1.0.jar --help` |
| `--config` | O caminho e o nome do seu arquivo `credentials.json`. |
| `--accessId` | Seu ID de chave de AWS acesso para o Task Runner usar ao fazer solicitações. As opções `--accessID` e `--secretKey` oferecem uma alternativa para usar um arquivo credentials.json. Se um arquivo `credentials.json` também for fornecido, as opções `--accessID` e `--secretKey` terão prioridade. |
| `--secretKey` | Sua chave AWS secreta para o Task Runner usar ao fazer solicitações. Para obter mais informações, consulte `--accessID`. |
| `--endpoint` | Um endpoint é um URL que é o ponto de entrada para um serviço da Web. O endpoint do AWS Data Pipeline serviço na região em que você está fazendo solicitações. Opcional. De modo geral, especificar uma região é suficiente e não há necessidade de definir o endpoint. Para obter uma lista de AWS Data Pipeline regiões e endpoints, consulte [Regiões e endpoints do AWS Data Pipeline](https://docs.aws.amazon.com/general/latest/gr/rande.html#datapipeline_region) no. *Referência geral da AWS* |
| `--workerGroup` | O nome do grupo de operadores para o qual o Task Runner recupera o trabalho. Obrigatório.Quando o Task Runner pesquisa o serviço web, ele usa as credenciais que você forneceu e o valor de `workerGroup` para selecionar as tarefas a serem recuperadas (se houver alguma). Você pode usar qualquer nome significativo para você. No entanto, a string precisa corresponder com o Task Runner e suas respectivas atividades de pipeline. O nome do grupo de operadores está vinculado a uma região. Mesmo que haja nomes idênticos de grupos de operadores em outras regiões, o Task Runner sempre receberá tarefas da região especificada em `--region`. |
| `--taskrunnerId` | O ID do executor de tarefas a ser usado para informar o andamento. Opcional. |
| `--output` | O diretório do Task Runner para os arquivos de saída de log. Opcional. Os arquivos de log ficam armazenados em um diretório local até serem enviados ao Amazon S3. Essa opção substituirá o diretório padrão. |
| `--region` | A região da a ser usada. Embora seja opcional, recomendamos que você sempre configure a região. Se você não especificar a região, o Task Runner recuperará as tarefas da região de serviços padrão, `us-east-1`.Outras regiões com suporte são: `eu-west-1`, `ap-northeast-1`, `ap-southeast-2`, `us-west-2`. |
| `--logUri` | O caminho de destino do Amazon S3 para que o Task Runner faça o backup dos arquivos de log de hora em hora. Quando o Task Runner encerra, logs ativos do diretório local são enviados para a pasta de destino do Amazon S3. |
| --proxyHost | O host do proxy usado pelos clientes do Task Runner na conexão com os serviços da AWS. |
| --proxyPort | Porta do host do proxy usado pelos clientes do Task Runner na conexão com os serviços da AWS. |
| --proxyUsername | O nome do usuário para o proxy. |
| --proxyPassword | A senha para o proxy. |
| --proxyDomain | O nome de domínio do Windows para o proxy NTLM. |
| --proxyWorkstation | O nome da estação de trabalho do Windows para o proxy NTLM. |
# Usar o Task Runner com um proxy
Se você estiver usando um host de proxy, poderá especificar a [configuração](https://docs.aws.amazon.com/datapipeline/latest/DeveloperGuide/dp-taskrunner-config-options.html) dele ao chamar o Task Runner ou configurar a variável de ambiente, HTTPS\$1PROXY. A variável de ambiente utilizada com o Task Runner aceitará a mesma configuração usada na [Interface da Linha de Comando da AWS](https://docs.aws.amazon.com/cli/latest/userguide/cli-http-proxy.html).
# Task Runner e Custom AMIs
Quando você especifica um `Ec2Resource` objeto para seu pipeline, AWS Data Pipeline cria uma instância do EC2 para você, usando uma AMI que instala e configura o Task Runner para você. É necessário um tipo de instância compatível com PV. Se preferir, você pode criar uma AMI personalizada com o Task Runner e, em seguida, especificar o ID dessa AMI usando o campo `imageId` do objeto `Ec2Resource`. Para obter mais informações, consulte [Ec2Resource](dp-object-ec2resource.md).
Uma AMI personalizada deve atender aos seguintes requisitos AWS Data Pipeline para usá-la com êxito no Task Runner:
+ Crie a AMI na mesma região em que as instâncias serão executadas. Para obter mais informações, consulte [Criar sua própria AMI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/creating-an-ami.html) no *Guia do usuário do Amazon EC2*.
+ Verifique se que o tipo de instância que você planeja usar oferece suporte ao tipo de virtualização da AMI. Por exemplo, os tipos de instância I2 e G2 requerem uma AMI HVM. Já os tipos de instância T1, C1, M1 e M2 requerem uma AMI PV. Para obter mais informações, consulte [Tipos de virtualização de AMI do Linux](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/virtualization_types.html) no *Guia do usuário do Amazon EC2*.
+ Instale o seguinte:
+ Linux
+ Bash
+ wget
+ unzip
+ Java 1.6 ou 1.8
+ cloud-init
+ Crie e configure um usuário chamado `ec2-user`.