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á.
# Versões 2.x e 3.x da AMI do Amazon EMR
**nota**
AWS está atualizando a configuração do TLS para todos os endpoints AWS da API para uma versão mínima do TLS 1.2. As versões 3.10 e anteriores do Amazon EMR são compatíveis somente com conexões TLS 1.0/1.1. Depois de 4 de dezembro de 2023, você não poderá criar clusters com as versões 3.10 e anteriores do Amazon EMR.
Se você usa as versões 3.10 ou anteriores do Amazon EMR, recomendamos que você teste e migre imediatamente suas workloads para a versão mais recente do Amazon EMR. Para obter mais informações, consulte o [Blog de segurança da AWS](https://aws.amazon.com/blogs//security/tls-1-2-required-for-aws-endpoints/).
As versões 2.x e 3.x do Amazon EMR, denominadas *versões da AMI*, são disponibilizadas para soluções preexistentes que as exigem por motivos de compatibilidade. Não recomendamos a criação de novos clusters ou novas soluções com essas versões. Elas não têm recursos de versões mais recentes e incluem pacotes de aplicativos desatualizados.
Recomendamos que você crie soluções usando a versão mais recente do Amazon EMR.
O grau de diferença entre as versões das séries 2.x e 3.x e as versões recentes do Amazon EMR é significativo. Essas diferenças vão desde como criar e configurar um cluster para as portas e a estrutura do diretório dos aplicativos no cluster.
Esta seção tenta abordar as diferenças mais significativas do Amazon EMR, bem como as diferenças específicas de configuração e gerenciamento de aplicações. Ela não é abrangente. Se você criar e usar clusters nas séries 2.x ou 3.x, poderá encontrar diferenças não abordadas nesta seção.
**Topics**
+ [Criar um cluster com versões anteriores da AMI do Amazon EMR](emr-3x-create.md)
+ [Instalar aplicações com versões anteriores da AMI do Amazon EMR](emr-3x-install-apps.md)
+ [Personalizar clusters e configurações de aplicações com versões anteriores da AMI do Amazon EMR](emr-3x-customizeappconfig.md)
+ [Detalhes da aplicação Hive para versões anteriores da AMI do Amazon EMR](emr-3x-hive.md)
+ [HBase especificações do aplicativo para versões anteriores da AMI do Amazon EMR](emr-3x-hbase.md)
+ [Detalhes da aplicação Pig para versões anteriores da AMI do Amazon EMR](emr-3x-pig.md)
+ [Detalhes de aplicações do Spark com versões anteriores da AMI do Amazon EMR](emr-3x-spark.md)
+ [Diferenças de DistCp utilidade do S3 com versões anteriores da AMI do Amazon EMR](emr-3x-s3distcp.md)
# Criar um cluster com versões anteriores da AMI do Amazon EMR
As versões 2.x e 3.x do Amazon EMR são conhecidas como versão da AMI. Desde as versões 4.0.0 e posteriores do Amazon EMR, as versões são designadas por um rótulo de versão, como `emr-5.11.0`. Essa alteração é mais aparente quando você cria um cluster usando o AWS CLI ou programaticamente.
Ao usar o AWS CLI para criar um cluster usando uma versão de lançamento da AMI, use a `--ami-version` opção, por exemplo,`--ami-version 3.11.0`. Muitas opções, atributos e aplicações apresentadas nas versões 4.0.0 e posteriores do Amazon EMR não estão disponíveis quando você especifica uma `--ami-version`. Para obter mais informações, consulte [create-cluster](https://docs.aws.amazon.com/cli/latest/reference/emr/create-cluster.html) na *AWS CLI Command Reference*.
O AWS CLI comando de exemplo a seguir inicia um cluster usando uma versão da AMI.
**nota**
Os caracteres de continuação de linha do Linux (\$1) são incluídos para facilitar a leitura. Eles podem ser removidos ou usados em comandos do Linux. No Windows, remova-os ou substitua-os por um sinal de interpolação (^).
```
aws emr create-cluster --name "Test cluster" --ami-version 3.11.0 \
--applications Name=Hue Name=Hive Name=Pig \
--use-default-roles --ec2-attributes KeyName=myKey \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,\
InstanceType=m3.xlarge InstanceGroupType=CORE,InstanceCount=2,\
InstanceType=m3.xlarge --bootstrap-actions Path=s3://elasticmapreduce/bootstrap-actions/configure-hadoop,\
Name="Configuring infinite JVM reuse",Args=["-m","mapred.job.reuse.jvm.num.tasks=-1"]
```
Programaticamente, todas as versões do Amazon EMR usam a ação `RunJobFlowRequest` na API do EMR para criar clusters. O seguinte exemplo de código Java cria um cluster usando a versão da AMI 3.11.0.
```
RunJobFlowRequest request = new RunJobFlowRequest()
.withName("AmiVersion Cluster")
.withAmiVersion("3.11.0")
.withInstances(new JobFlowInstancesConfig()
.withEc2KeyName("myKeyPair")
.withInstanceCount(1)
.withKeepJobFlowAliveWhenNoSteps(true)
.withMasterInstanceType("m3.xlarge")
.withSlaveInstanceType("m3.xlarge");
```
A chamada `RunJobFlowRequest` usa um rótulo de versão:
```
RunJobFlowRequest request = new RunJobFlowRequest()
.withName("ReleaseLabel Cluster")
.withReleaseLabel("emr-7.12.0")
.withInstances(new JobFlowInstancesConfig()
.withEc2KeyName("myKeyPair")
.withInstanceCount(1)
.withKeepJobFlowAliveWhenNoSteps(true)
.withMasterInstanceType("m3.xlarge")
.withSlaveInstanceType("m3.xlarge");
```
## Configurar o tamanho do cluster
Durante a execução do cluster, o Hadoop determina o número de tarefas de mapeador e reducer necessárias para processar os dados. Clusters maiores devem ter mais tarefas para fazer melhor utilização dos recursos e reduzir o tempo de processamento. Normalmente, um cluster do EMR permanece do mesmo tamanho durante toda a execução do cluster; você define o número de tarefas ao criar o cluster. Quando você redimensiona um cluster em execução, pode variar o processamento durante a execução do cluster. Portanto, em vez de usar um número fixo de tarefas, você pode variar o número de tarefas durante a vida útil do cluster. Há duas opções de configuração para ajudar a definir o número ideal de tarefas:
+ `mapred.map.tasksperslot`
+ `mapred.reduce.tasksperslot`
Você pode definir ambas as opções no arquivo `mapred-conf.xml`. Quando você envia um trabalho para o cluster, o cliente do trabalho verifica o número total de slots de mapeamento e redução em todo o cluster. O cliente do trabalho, em seguida, usa as seguintes equações para definir o número de tarefas:
+ `mapred.map.tasks` =` mapred.map.tasksperslot` \$1 slots de mapeamento no cluster
+ `mapred.reduce.tasks` = `mapred.reduce.tasksperslot` \$1 slots de redução no cluster
O cliente do trabalho lê o parâmetro `tasksperslot` somente se o número de tarefas não estiver configurado. Você pode substituir o número de tarefas a qualquer momento para todos os clusters por meio de uma ação de bootstrap, ou pode fazê-lo individualmente por trabalho, adicionando uma etapa para alterar a configuração.
O Amazon EMR é capaz de superar falhas de nós de tarefas e prosseguir com a execução do cluster, mesmo que o nó de tarefa se torne indisponível. O Amazon EMR disponibiliza automaticamente nós de tarefa adicionais para substituir aqueles que falham.
Você pode ter um número diferente de nós de tarefa para cada etapa do cluster. Você também pode adicionar uma etapa em um cluster em execução para modificar o número de nós de tarefa. Como é certo que todas as etapas são executadas sequencialmente por padrão, você pode especificar o número de nós de tarefa em execução para qualquer etapa.
# Instalar aplicações com versões anteriores da AMI do Amazon EMR
Ao usar uma versão da AMI, os aplicativos são instalados de várias maneiras, inclusive usando o `NewSupportedProducts` parâmetro para a [RunJobFlow](https://docs.aws.amazon.com/ElasticMapReduce/latest/API/API_RunJobFlow.html)ação, usando ações de bootstrap e usando a ação [Step](https://docs.aws.amazon.com/ElasticMapReduce/latest/API/API_Step.html).
# Personalizar clusters e configurações de aplicações com versões anteriores da AMI do Amazon EMR
A versão 4.0.0 do Amazon EMR introduziu um método simplificado de configuração de aplicações usando classificações de configuração. Para obter mais informações, consulte [Configurar aplicações](emr-configure-apps.md). Ao usar uma versão da AMI, você configura aplicativos usando ações de bootstrap juntamente com os argumentos que transmite. Por exemplo, as ações de bootstrap `configure-hadoop` e `configure-daemons` definem propriedades do ambiente específicas do Hadoop e do YARN, como `--namenode-heap-size`. Em versões mais recentes, elas são configuradas usando as classificações de configuração `hadoop-env` e `yarn-env`. Para ações de bootstrap que realizam configurações comuns, consulte o [emr-bootstrap-actions repositório no Github.](https://github.com/awslabs/emr-bootstrap-actions)
As tabelas a seguir mapeiam ações de bootstrap para classificações de configuração em versões mais recentes do Amazon EMR.
**Hadoop**
| Nome do arquivo de aplicativo afetado | Ação de bootstrap da versão da AMI | Classificação de configuração |
| --- | --- | --- |
| core-site.xml | configure-hadoop -c | core-site |
| log4j.properties | configure-hadoop -l | hadoop-log4j |
| hdfs-site.xml | configure-hadoop -s | hdfs-site |
| n/a | n/a | hdfs-encryption-zones |
| mapred-site.xml | configure-hadoop -m | mapred-site |
| yarn-site.xml | configure-hadoop -y | yarn-site |
| httpfs-site.xml | configure-hadoop -t | httpfs-site |
| capacity-scheduler.xml | configure-hadoop -z | capacity-scheduler |
| yarn-env.sh | configure-daemons --resourcemanager-opts | yarn-env |
**Hive**
| Nome do arquivo de aplicativo afetado | Ação de bootstrap da versão da AMI | Classificação de configuração |
| --- | --- | --- |
| hive-env.sh | n/a | hive-env |
| hive-site.xml | hive-script --install-hive-site \$1\$1MY\$1HIVE\$1SITE\$1FILE\$1 | hive-site |
| hive-exec-log4j.properties | n/a | hive-exec-log4j |
| hive-log4j.properties | n/a | hive-log4j |
**EMRFS**
| Nome do arquivo de aplicativo afetado | Ação de bootstrap da versão da AMI | Classificação de configuração |
| --- | --- | --- |
| emrfs-site.xml | configure-hadoop -e | emrfs-site |
| n/a | s3get -s s3://custom-provider.jar -d /usr/share/aws/emr/auxlib/ | emrfs-site (com nova configuração fs.s3.cse.encryptionMaterialsProvider.uri) |
Para obter uma lista de todas as classificações, consulte [Configurar aplicações](emr-configure-apps.md).
## Variáveis de ambientes de aplicações
Quando você usa uma versão da AMI, um script `hadoop-user-env.sh` é usado juntamente com a ação de bootstrap `configure-daemons` para configurar o ambiente do Hadoop. O script inclui as seguintes ações:
```
#!/bin/bash
export HADOOP_USER_CLASSPATH_FIRST=true;
echo "HADOOP_CLASSPATH=/path/to/my.jar" >> /home/hadoop/conf/hadoop-user-env.sh
```
Na versão 4.x do Amazon EMR, você faz o mesmo usando a classificação de configuração `hadoop-env`, conforme mostrado no exemplo a seguir:
```
[
{
"Classification":"hadoop-env",
"Properties":{
},
"Configurations":[
{
"Classification":"export",
"Properties":{
"HADOOP_USER_CLASSPATH_FIRST":"true",
"HADOOP_CLASSPATH":"/path/to/my.jar"
}
}
]
}
]
```
Como outro exemplo, usar `configure-daemons` e transmitir `--namenode-heap-size=2048` e `--namenode-opts=-XX:GCTimeRatio=19` é equivalente às seguintes classificações de configuração.
```
[
{
"Classification":"hadoop-env",
"Properties":{
},
"Configurations":[
{
"Classification":"export",
"Properties":{
"HADOOP_DATANODE_HEAPSIZE": "2048",
"HADOOP_NAMENODE_OPTS": "-XX:GCTimeRatio=19"
}
}
]
}
]
```
As outras variáveis do ambiente de aplicativos não são mais definidas em `/home/hadoop/.bashrc`. Em vez disso, elas são definidas nos arquivos `/etc/default` por componente ou aplicativo, como por exemplo `/etc/default/hadoop`. Os scripts de wrapper `/usr/bin/` instalados pelo aplicativo também RPMs podem definir variáveis de ambiente adicionais antes de envolver o script bin real.
## Portas de serviço
Ao usar uma versão da AMI, alguns serviços usam portas personalizadas.
**Alterações nas configurações das portas**
| Configuração | AMI versão 3.x | Padrão de código aberto |
| --- | --- | --- |
| fs.default.name | hdfs://emrDeterminedIP:9000 | padrão (hdfs: emrDeterminedIP //:8020) |
| dfs.datanode.address | 0.0.0.0:9200 | default (0.0.0.0:50010) |
| dfs.datanode.http.address | 0.0.0.0:9102 | default (0.0.0.0:50075) |
| dfs.datanode.https.address | 0.0.0.0:9402 | default (0.0.0.0:50475) |
| dfs.datanode.ipc.address | 0.0.0.0:9201 | default (0.0.0.0:50020) |
| dfs.http.address | 0.0.0.0:9101 | default (0.0.0.0:50070) |
| dfs.https.address | 0.0.0.0:9202 | default (0.0.0.0:50470) |
| dfs.secondary.http.address | 0.0.0.0:9104 | default (0.0.0.0:50090) |
| yarn.nodemanager.address | 0.0.0.0:9103 | default (\$1\$1yarn.nodemanager.hostname\$1:0) |
| yarn.nodemanager.localizer.address | 0.0.0.0:9033 | default (\$1\$1yarn.nodemanager.hostname\$1:8040) |
| yarn.nodemanager.webapp.address | 0.0.0.0:9035 | default (\$1\$1yarn.nodemanager.hostname\$1:8042) |
| yarn.resourcemanager.address | emrDeterminedIP: 9022 | default (\$1\$1yarn.resourcemanager.hostname\$1:8032) |
| yarn.resourcemanager.admin.address | emrDeterminedIP: 9025 | default (\$1\$1yarn.resourcemanager.hostname\$1:8033) |
| yarn.resourcemanager.resource-tracker.address | emrDeterminedIP: 9023 | default (\$1\$1yarn.resourcemanager.hostname\$1:8031) |
| yarn.resourcemanager.scheduler.address | emrDeterminedIP: 9024 | default (\$1\$1yarn.resourcemanager.hostname\$1:8030) |
| yarn.resourcemanager.webapp.address | 0.0.0.0:9026 | default (\$1\$1yarn.resourcemanager.hostname\$1:8088) |
| yarn.web-proxy.address | emrDeterminedIP: 9046 | default (no-value) |
| yarn.resourcemanager.hostname | 0.0.0.0 (default) | emrDeterminedIP |
**nota**
*emrDeterminedIP*É um endereço IP gerado pelo Amazon EMR.
## Usuários
Ao usar uma versão da AMI, o usuário `hadoop` executa todos os processos e é proprietário de todos os arquivos. Nas versões 4.0.0 e posteriores do Amazon EMR, existem usuários no nível da aplicação e dos componentes.
## Sequência de instalação, artefatos instalados e locais dos arquivos de log
Ao usar uma versão da AMI, os artefatos de aplicativos e seus diretórios de configuração são instalados no diretório `/home/hadoop/application`. Por exemplo, se você tivesse o Hive instalado, o diretório seria `/home/hadoop/hive`. Nas versões 4.0.0 e posteriores do Amazon EMR, os artefatos de aplicações são instalados no diretório `/usr/lib/application`. Ao usar uma versão da AMI, os arquivos de log são encontrados em vários locais. A tabela a seguir lista os locais.
**Alterações nos locais de log no Amazon S3**
| Daemon ou aplicação | Local do diretório |
| --- | --- |
| instance-state | nodo/ /instance-state/ instance-id |
| hadoop-hdfs-namenode | instance-iddaemons///.log hadoop-hadoop-namenode |
| hadoop-hdfs-datanode | instance-iddaemons///.log hadoop-hadoop-datanode |
| fio de hadoop () ResourceManager | instance-iddaemons//yarn-hadoop-resourcemanager |
| hadoop-yarn (Proxy Server) | instance-iddaemons//yarn-hadoop-proxyserver |
| mapred-historyserver | instance-iddaemons// |
| httpfs | instance-iddaemons/ /httpfs.log |
| hive-server | node/ /hive-server/hive-server.log instance-id |
| hive-metastore | node/ /apps/hive.log instance-id |
| CLI do Hive | node/ /apps/hive.log instance-id |
| Logs de usuário e logs de contêiner dos aplicativos YARN | task-attempts/ |
| Mahout | N/D |
| Pig | N/D |
| spark-historyserver | N/D |
| Arquivos de histórico de trabalhos do mapreduce | jobs/ |
## Executor de comandos
Quando uma versão da AMI é usada, muitos scripts ou programas como, por exemplo `/home/hadoop/contrib/streaming/hadoop-streaming.jar`, não são colocados no ambiente do caminho de login do shell. Portanto, você precisa especificar o caminho completo ao usar um arquivo jar, como command-runner.jar ou script-runner.jar, para executar os scripts. O `command-runner.jar` está localizado na AMI; portanto, não há necessidade de conhecer um URI completo, como era o caso com `script-runner.jar`.
## Fator de replicação
O fator de replicação permite que você configure quando uma JVM do Hadoop deverá ser iniciada. Você pode iniciar uma nova JVM do Hadoop para cada tarefa, o que fornece melhor isolamento de tarefas, ou você pode compartilhar JVMs entre tarefas, fornecendo menor sobrecarga da estrutura. Se você estiver processando vários arquivos pequenos, faz sentido reutilizar o JVM muitas vezes para amortizar o custo de startup. No entanto, se cada tarefa demora ou processa uma grande quantidade de dados, você pode optar por não reutilizar o JVM para garantir que toda a memória esteja liberada para as tarefas subsequentes. Ao usar uma versão da AMI, você pode personalizar o fator de replicação usando a ação de bootstrap `configure-hadoop` para definir a propriedade `mapred.job.reuse.jvm.num.tasks`.
O exemplo a seguir demonstra como configurar o fator de reutilização da JVM para a reutilização infinita da JVM.
**nota**
Os caracteres de continuação de linha do Linux (\$1) são incluídos para facilitar a leitura. Eles podem ser removidos ou usados em comandos do Linux. No Windows, remova-os ou substitua-os por um sinal de interpolação (^).
```
aws emr create-cluster --name "Test cluster" --ami-version 3.11.0 \
--applications Name=Hue Name=Hive Name=Pig \
--use-default-roles --ec2-attributes KeyName=myKey \
--instance-groups InstanceGroupType=MASTER,InstanceCount=1,InstanceType=m3.xlarge \
InstanceGroupType=CORE,InstanceCount=2,InstanceType=m3.xlarge \
--bootstrap-actions Path=s3://elasticmapreduce/bootstrap-actions/configure-hadoop,\
Name="Configuring infinite JVM reuse",Args=["-m","mapred.job.reuse.jvm.num.tasks=-1"]
```
# Detalhes da aplicação Hive para versões anteriores da AMI do Amazon EMR
## Arquivos de log
Com o uso das versões 2.x e 3.x da AMI do Amazon EMR, os logs do Hive são salvos em `/mnt/var/log/apps/`. Para oferecer suporte a versões simultâneas do Hive, a versão do Hive que você executa determina o nome do arquivo de log, conforme mostrado na tabela a seguir.
| Versão do Hive | Nome do arquivo de log |
| --- | --- |
| 0.13.1 | hive.log Desde esta desta versão, o Amazon EMR usa um nome de arquivo sem versionamento, `hive.log`. Versões secundárias compartilham o mesmo local de log que a versão principal. |
| 0.11.0 | hive\$10110.log As versões secundárias do Hive 0.11.0, como o Hive 0.11.0.1, compartilham o mesmo local de arquivo de log que o Hive 0.11.0. |
| 0.8.1 | hive\$1081.log As versões secundárias do Hive 0.8.1, como o Hive 0.8.1.1, compartilham o mesmo local de arquivo de log que o Hive 0.8.1. |
| 0.7.1 | hive\$107\$11.log As versões secundárias do Hive 0.7.1, como o Hive 0.7.1.3 e o Hive 0.7.1.4, compartilham o mesmo local de arquivo de log que o Hive 0.7.1. |
| 0.7 | hive\$107.log |
| 0,5 | hive\$105.log |
| 0.4 | hive.log |
## Funcionalidade de entrada dividida
Para implementar a funcionalidade de entrada dividida usando as versões do Hive anteriores à versão 0.13.1 (versões da AMI do Amazon EMR anteriores à versão 3.11.0), use o seguinte:
```
hive> set hive.input.format=org.apache.hadoop.hive.ql.io.HiveCombineSplitsInputFormat;
hive> set mapred.min.split.size=100000000;
```
Essa funcionalidade se tornou obsoleta com o Hive 0.13.1. Para obter a mesma funcionalidade de formato de entrada dividido na versão 3.11.0 da AMI do Amazon EMR, use o seguinte:
```
set hive.hadoop.supports.splittable.combineinputformat=true;
```
## Portas de serviço do Thrift
O Thrift é uma estrutura RPC que define um formato compacto de serialização de binários usado para manter estruturas de dados para análise posterior. Normalmente, o Hive configura o servidor para operar nas seguintes portas.
| Versão do Hive | Número da porta |
| --- | --- |
| Hive 0.13.1 | 10000 |
| Hive 0.11.0 | 10004 |
| Hive 0.8.1 | 10003 |
| Hive 0.7.1 | 10002 |
| Hive 0.7 | 10001 |
| Hive 0.5 | 10000 |
Para obter mais informações sobre serviços do Thrift, consulte [http://wiki.apache.org/thrift/](http://wiki.apache.org/thrift/).
## Usar o Hive para recuperar partições
O Amazon EMR inclui uma instrução na linguagem de consulta Hive que recupera as partições de uma tabela dos dados de tabela localizados no Amazon s3. O exemplo a seguir mostra isso.
```
CREATE EXTERNAL TABLE (json string) raw_impression
PARTITIONED BY (dt string)
LOCATION 's3://elastic-mapreduce/samples/hive-ads/tables/impressions';
ALTER TABLE logs RECOVER PARTITIONS;
```
Os dados e diretórios da partição devem estar na localização especificada na definição de tabela e devem ser nomeados de acordo com a convenção do Hive: por exemplo, `dt=2009-01-01`.
**nota**
Depois do Hive 0.13.1, esse recurso tem suporte nativamente usando `msck repair table` e, portanto, `recover partitions` não tem suporte. Para obter mais informações, consulte [https://cwiki.apache. org/confluence/display/Hive/LanguageManual\$1DDL](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL).
## Transmitir uma variável do Hive para um script
Para passar uma variável para uma etapa do Hive usando o AWS CLI, digite o comando a seguir, *myKey* substitua pelo nome do seu par de chaves do EC2 e *amzn-s3-demo-bucket* substitua pelo nome do seu bucket. Neste exemplo, `SAMPLE` é um valor de variável precedido pela opção `-d`. Essa variável é definida no script Hive como: `${SAMPLE}`.
**nota**
Os caracteres de continuação de linha do Linux (\$1) são incluídos para facilitar a leitura. Eles podem ser removidos ou usados em comandos do Linux. No Windows, remova-os ou substitua-os por um sinal de interpolação (^).
```
aws emr create-cluster --name "Test cluster" --ami-version 3.9 \
--applications Name=Hue Name=Hive Name=Pig \
--use-default-roles --ec2-attributes KeyName=myKey \
--instance-type m3.xlarge --instance-count 3 \
--steps Type=Hive,Name="Hive Program",ActionOnFailure=CONTINUE,\
Args=[-f,s3://elasticmapreduce/samples/hive-ads/libs/response-time-stats.q,-d,\
INPUT=s3://elasticmapreduce/samples/hive-ads/tables,-d,OUTPUT=s3://amzn-s3-demo-bucket/hive-ads/output/,\
-d,SAMPLE=s3://elasticmapreduce/samples/hive-ads/]
```
## Especificar um local de metastore externo
O procedimento a seguir mostra como substituir os valores de configuração padrão para a localização da metastore do Hive e iniciar um cluster usando a localização da metastore reconfigurada.
**Para criar uma metastore localizada fora do cluster do EMR**
1. Crie um banco de dados MySQL ou Aurora usando o Amazon RDS.
Para obter informações sobre como criar um banco de dados do Amazon RDS, consulte [Conceitos básicos do Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/CHAP_GettingStarted.html).
1. Modifique seus grupos de segurança para permitir conexões JDBC entre seu banco de dados e o grupo de segurança **ElasticMapReduce-Master**.
Para obter informações sobre como modificar os grupos de segurança quanto ao acesso, consulte [Grupos de segurança do Amazon RDS](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Overview.RDSSecurityGroups.html) no *Guia do usuário do Amazon RDS*.
1. Defina os valores de configuração do JDBC em `hive-site.xml`:
1. Crie um arquivo de configuração `hive-site.xml` contendo as seguintes informações:
```
javax.jdo.option.ConnectionURL
jdbc:mariadb://hostname:3306/hive?createDatabaseIfNotExist=true
JDBC connect string for a JDBC metastore
javax.jdo.option.ConnectionUserName
hive
Username to use against metastore database
javax.jdo.option.ConnectionPassword
password
Password to use against metastore database
```
*hostname*é o endereço DNS da instância do Amazon RDS que executa o banco de dados. *username*e *password* são as credenciais do seu banco de dados. Para obter mais informações sobre como se conectar a instâncias de banco de dados MySQL e Aurora, consulte [Conectar-se a uma instância de banco de dados executando o mecanismo de banco de dados MySQL](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/USER_ConnectToInstance.html) e [Conectar-se a um cluster de banco de dados do Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/UserGuide/Aurora.Connecting.html) no *Guia do usuário do Amazon RDS*.
Os drivers JDBC são instalados pelo Amazon EMR.
**nota**
A propriedade "value" não deve conter espaços ou retornos de carro. Eles devem aparecer todos em uma única linha.
1. Salve o arquivo `hive-site.xml` em um local no Amazon S3, como `s3://amzn-s3-demo-bucket/hive-site.xml`.
1. Crie um cluster especificando a localização do Amazon S3 do arquivo `hive-site.xml` personalizado.
O exemplo de comando a seguir demonstra um AWS CLI comando que faz isso.
**nota**
Os caracteres de continuação de linha do Linux (\$1) são incluídos para facilitar a leitura. Eles podem ser removidos ou usados em comandos do Linux. No Windows, remova-os ou substitua-os por um sinal de interpolação (^).
```
aws emr create-cluster --name "Test cluster" --ami-version 3.10 \
--applications Name=Hue Name=Hive Name=Pig \
--use-default-roles --ec2-attributes KeyName=myKey \
--instance-type m3.xlarge --instance-count 3 \
--bootstrap-actions Name="Install Hive Site Configuration",\
Path="s3://region.elasticmapreduce/libs/hive/hive-script",\
Args=["--base-path","s3://elasticmapreduce/libs/hive","--install-hive-site",\
"--hive-site=s3://amzn-s3-demo-bucket/hive-site.xml","--hive-versions","latest"]
```
## Conectar-se com o Hive usando JDBC
Para se conectar ao Hive por meio do JDBC você precisa fazer o download do driver do JDBC e instalar um cliente SQL. O exemplo a seguir demonstra o uso do SQL Workbench/J para se conectar ao Hive usando o JDBC.
**Para fazer download dos drivers do JDBC**
1. Faça o download e extraia os drivers apropriados para as versões do Hive que você deseja acessar. A versão do Hive depende da AMI escolhida na criação de um cluster do Amazon EMR.
+ [Drivers JDBC Hive 0.13.1: JDBC\$11.0.4.1004.zip https://amazon-odbc-jdbc-drivers.s3.amazonaws.com/public/ AmazonHive](https://amazon-odbc-jdbc-drivers.s3.amazonaws.com/public/AmazonHiveJDBC_1.0.4.1004.zip)
+ Drivers JDBC do Hive 0.11.0: [https://mvnrepository.com/artifact/org.apache.hive/hive-jdbc/0.11.0](https://mvnrepository.com/artifact/org.apache.hive/hive-jdbc/0.11.0)
+ Drivers JDBC do Hive 0.8.1: [https://mvnrepository.com/artifact/org.apache.hive/hive-jdbc/0.8.1](https://mvnrepository.com/artifact/org.apache.hive/hive-jdbc/0.8.1)
1. Instale o SQL Workbench/J. Para obter mais informações, consulte [Instalando e iniciando o SQL Workbench/J](http://www.sql-workbench.net/manual/install.html) no Manual do Usuário do SQL Manual. Workbench/J
1. Crie um túnel do SSH no nó principal do cluster. A porta de conexão é diferente dependendo da versão do Hive. Comandos de exemplo são fornecidos nas tabelas abaixo para usuários do `ssh` do Linux e comandos do PuTTY para usuários do Windows
**Comandos SSH do Linux**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/emr/latest/ReleaseGuide/emr-3x-hive.html)
**Configurações do túnel no PuTTY do Windows**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/emr/latest/ReleaseGuide/emr-3x-hive.html)
1. Adicione o driver do JDBC ao SQL Workbench.
1. Na caixa de diálogo **Select Connection Profile (Selecionar perfil de conexão)**, escolha **Manage Drivers (Gerenciar drivers)**.
1. Escolha o ícone **Create a new entry (Criar uma nova entrada)** (página em branco).
1. No campo **Name (Nome)**, digite **Hive JDBC**.
1. Em **Library (Biblioteca)**, clique no ícone **Select the JAR file(s) (Selecionar os arquivos JAR)**.
1. Selecione arquivos JAR, conforme mostrado na tabela a seguir.
****
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/emr/latest/ReleaseGuide/emr-3x-hive.html)
1. Na caixa de diálogo **Please select one driver (Selecione um driver)**, selecione um driver de acordo com a tabela a seguir e clique em **OK**.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/emr/latest/ReleaseGuide/emr-3x-hive.html)
1. Quando você retornar para a caixa de diálogo Selecionar perfil de conexão, verifique se o campo **Driver** está definido como **JDBC do Hive** e forneça a string de conexão JDBC no campo **URL** de acordo com a tabela a seguir.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/emr/latest/ReleaseGuide/emr-3x-hive.html)
Se o seu cluster usa a AMI versão 3.3.1 ou posterior, na caixa de diálogo **Select Connection Profile (Selecionar perfil de conexão)**, digite **hadoop** no campo **Username (Nome de usuário)**.
# HBase especificações do aplicativo para versões anteriores da AMI do Amazon EMR
## HBase Versões suportadas
| HBase versão | AMI version | AWS CLI parâmetros de configuração | HBase detalhes da versão |
| --- | --- | --- | --- |
| [0.94.18](https://svn.apache.org/repos/asf/hbase/branches/0.94/CHANGES.txt) | 3.1.0 e posterior | `--ami-version 3.1` `--ami-version 3.2` `--ami-version 3.3` `--applications Name=HBase` | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/emr/latest/ReleaseGuide/emr-3x-hbase.html) |
| [0.94.7](https://svn.apache.org/repos/asf/hbase/branches/0.94/CHANGES.txt) | 3.0-3.0.4 | `--ami-version 3.0` `--applications Name=HBase` |
| [0.92](https://svn.apache.org/repos/asf/hbase/branches/0.92/CHANGES.txt) | 2.2 e posterior | `--ami-version 2.2 or later` `--applications Name=HBase` |
## HBase pré-requisitos do cluster
Um cluster criado usando as versões 2.x e 3.x da AMI do Amazon EMR deve atender aos seguintes requisitos para. HBase
+ O AWS CLI (opcional) — Para interagir HBase usando a linha de comando, baixe e instale a versão mais recente do AWS CLI. Para obter mais informações, consulte [Instalar a AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) no *Guia do usuário da AWS Command Line Interface *.
+ Pelo menos duas instâncias (opcionais): o nó principal do cluster executa o servidor mestre HBase e o Zookeeper, enquanto os nós de tarefa executam os servidores da região do HBase. Para obter o melhor desempenho, os clusters do HBase devem ser executados em pelo menos duas instâncias do EC2, mas você pode ser executado HBase em um único nó para fins de avaliação.
+ Cluster de longa duração — HBase só é executado em clusters de longa duração. Por padrão, a CLI e o console do Amazon EMR criam clusters de execução prolongada.
+ Um par de chaves do Amazon EC2 definido (recomendado): para usar o protocolo de rede Secure Shell (SSH) para conectar-se ao nó principal e executar comandos de shell do HBase, você deve usar um par de chaves do Amazon EC2 ao criar o cluster.
+ As versões corretas da AMI e do Hadoop — atualmente, os HBase clusters são suportados somente no Hadoop 20.205 ou posterior.
+ Ganglia (opcional) — Para monitorar as métricas de HBase desempenho, instale o Ganglia ao criar o cluster.
+ Um bucket do Amazon S3 para registros (opcional) — Os registros para HBase estão disponíveis no nó principal. Se você quiser que esses logs sejam copiados para o Amazon S3, especifique um bucket do S3 para receber arquivos de log quando criar o cluster.
## Criação de um cluster com HBase
A tabela a seguir lista as opções que estão disponíveis ao usar o console para criar um cluster HBase usando uma versão de lançamento da AMI do Amazon EMR.
| Campo | Ação |
| --- | --- |
| Restore from backup (Restauração de backup) | Especifique se deseja pré-carregar o HBase cluster com dados armazenados no Amazon S3. |
| Backup location (Localização do backup) | Especifique o URI no qual o backup para restauração reside no Amazon S3. |
| Backup version (Versão do backup) | Opcionalmente, especifique o nome da versão do backup para uso em Backup Location (Localização do backup). Se você deixar esse campo em branco, o Amazon EMR usará o backup mais recente no Local de Backup para preencher o novo cluster. HBase |
| Schedule Regular Backups (Agendar backups regulares) | Especifique se deseja agendar backups incrementais automáticos. O primeiro backup é um backup completo para criar uma linha de base para futuros backups incrementais. |
| Consistent backup (Backup consistente) | Especifica se os backups devem ser consistentes. Um backup consistente é aquele que pausa operações de gravação durante o estágio de backup inicial, a sincronização entre nós. Qualquer operações de gravação assim pausada é colocada em uma fila e retomada quando a sincronização é concluída. |
| Backup frequency (Frequência de backup) | O número de days/hours/minutes backups programados. |
| Backup location (Localização do backup) | O URI do Amazon S3 em que os backups são armazenados. O local de backup de cada HBase cluster deve ser diferente para garantir que os backups diferenciais permaneçam corretos. |
| Backup start time (Hora de início do backup) | Especifique quando o primeiro backup deve ocorrer. Você pode definir isso como now, o que faz com que o primeiro backup comece assim que o cluster estiver em execução, ou inserir uma data e uma hora no [formato ISO](http://www.w3.org/TR/NOTE-datetime). Por exemplo, 2012-06-15T20:00Z define a hora de início como 15 de junho de 2012 às 8 p.m. UTC. |
O AWS CLI comando de exemplo a seguir inicia um cluster com HBase e outros aplicativos:
**nota**
Os caracteres de continuação de linha do Linux (\$1) são incluídos para facilitar a leitura. Eles podem ser removidos ou usados em comandos do Linux. No Windows, remova-os ou substitua-os por um sinal de interpolação (^).
```
aws emr create-cluster --name "Test cluster" --ami-version 3.3 \
--applications Name=Hue Name=Hive Name=Pig Name=HBase \
--use-default-roles --ec2-attributes KeyName=myKey \
--instance-type c1.xlarge --instance-count 3 --termination-protected
```
Depois que a conexão entre o Hive e os HBase clusters for estabelecida (conforme mostrado no procedimento anterior), você poderá acessar os dados armazenados no HBase cluster criando uma tabela externa no Hive.
O exemplo a seguir, quando executado a partir do prompt do Hive, cria uma tabela externa que faz referência aos dados armazenados em uma HBase tabela chamada`inputTable`. Em seguida, você pode fazer referência `inputTable` nas instruções do Hive para consultar e modificar os dados armazenados no HBase cluster.
**nota**
O exemplo a seguir usa **protobuf-java-2.4.0a.jar** na AMI 2.3.3, mas você deve modificar o exemplo para corresponder à sua versão. Para verificar qual é a sua versão do Protocol Buffers JAR, execute o comando no prompt de comando do Hive: `! ls /home/hadoop/lib;`.
```
add jar lib/emr-metrics-1.0.jar ;
add jar lib/protobuf-java-2.4.0a.jar ;
set hbase.zookeeper.quorum=ec2-107-21-163-157.compute-1.amazonaws.com ;
create external table inputTable (key string, value string)
stored by 'org.apache.hadoop.hive.hbase.HBaseStorageHandler'
with serdeproperties ("hbase.columns.mapping" = ":key,f1:col1")
tblproperties ("hbase.table.name" = "t1");
select count(*) from inputTable ;
```
## Personalizando a configuração HBase
Embora as configurações padrão devam funcionar para a maioria dos aplicativos, você tem a flexibilidade de modificar suas HBase configurações. Para fazer isso, execute um dos dois scripts de ação de bootstrap:
+ **configure-hbase-daemons**— Configura as propriedades dos daemons master, regionserver e zookeeper. Essas propriedades incluem o tamanho da pilha e as opções a serem passadas para a Java Virtual Machine (JVM) quando o HBase daemon é iniciado. Você pode definir essas propriedades como argumentos na ação de bootstrap. Essa ação de bootstrap modifica o arquivo de configuração/home/hadoop/conf/hbase-user-env.sh no HBase cluster.
+ **configure-hbase** — Define configurações HBase específicas do site, como a porta à qual o HBase mestre deve se vincular e o número máximo de vezes que o cliente CLI do cliente deve repetir uma ação. Você pode defini-los one-by-one como argumentos na ação bootstrap ou especificar a localização de um arquivo de configuração XML no Amazon S3. Essa ação de bootstrap modifica o arquivo de configuração/home/hadoop/conf/hbase-site.xml no HBase cluster.
**nota**
Esses scripts, como outras ações de bootstrap, só podem ser executados quando o cluster é criado; você não pode usá-los para alterar a configuração de um HBase cluster em execução no momento.
Quando você executa as ações **configure-hbase** ou **configure-hbase-daemons**bootstrap, os valores especificados substituem os valores padrão. Todos os valores não explicitamente definidos recebem os valores padrão.
Configurar HBase com essas ações de bootstrap é análogo ao uso de ações de bootstrap no Amazon EMR para definir as configurações do Hadoop e as propriedades do daemon do Hadoop. A diferença é que HBase não tem opções de memória por processo. Em vez disso, as opções de memória são definidas usando o `--daemon-opts` argumento, onde *daemon* é substituído pelo nome do daemon a ser configurado.
### Configurar HBase daemons
O Amazon EMR fornece uma ação de bootstrap,`s3://region.elasticmapreduce/bootstrap-actions/configure-hbase-daemons`, que você pode usar para alterar a configuração dos HBase daemons, onde *region* é a região na qual você está lançando seu cluster. HBase
Para configurar HBase daemons usando o AWS CLI, adicione a ação `configure-hbase-daemons` bootstrap ao iniciar o cluster para configurar um ou mais daemons. HBase É possível definir as seguintes propriedades.
| Propriedade | Description |
| --- | --- |
| hbase-master-opts | Opções que controlam como a JVM executa o daemon principal. Se definidas, estas substituirão as variáveis HBASE\$1MASTER\$1OPTS padrão. |
| regionserver-opts | Opções que controlam como a JVM executa o daemon do servidor de regiões. Se definidas, estas substituirão as variáveis HBASE\$1REGIONSERVER\$1OPTS padrão. |
| zookeeper-opts | Opções que controlam como a JVM executa o daemon zookeeper. Se definidas, estas substituirão as variáveis HBASE\$1ZOOKEEPER\$1OPTS padrão. |
Para obter mais informações sobre essas opções, consulte [hbase-env.sh](https://hbase.apache.org/book.html#hbase.env.sh) na HBase documentação.
O exemplo a seguir mostra uma ação de bootstrap para configurar valores para `zookeeper-opts` e `hbase-master-opts`.
**nota**
Os caracteres de continuação de linha do Linux (\$1) são incluídos para facilitar a leitura. Eles podem ser removidos ou usados em comandos do Linux. No Windows, remova-os ou substitua-os por um sinal de interpolação (^).
```
aws emr create-cluster --name "Test cluster" --ami-version 3.3 \
--applications Name=Hue Name=Hive Name=Pig Name=HBase \
--use-default-roles --ec2-attributes KeyName=myKey \
--instance-type c1.xlarge --instance-count 3 --termination-protected \
--bootstrap-actions Path=s3://elasticmapreduce/bootstrap-actions/configure-hbase-daemons,\
Args=["--hbase-zookeeper-opts=-Xmx1024m -XX:GCTimeRatio=19","--hbase-master-opts=-Xmx2048m","--hbase-regionserver-opts=-Xmx4096m"]
```
### Definir as configurações do HBase site
O Amazon EMR fornece uma ação de bootstrap,`s3://elasticmapreduce/bootstrap-actions/configure-hbase`, que você pode usar para alterar a configuração do. HBase Você pode definir valores de configuração one-by-one, como argumentos na ação bootstrap, ou você pode especificar a localização de um arquivo de configuração XML no Amazon S3. Definir valores de configuração one-by-one é útil se você precisar definir apenas algumas configurações. Defini-los usando um arquivo XML é útil quando há muitas mudanças por fazer, ou se você deseja salvar as definições de configuração para reutilização.
**nota**
Você pode prefixar o nome do bucket do Amazon S3 com um prefixo de região, `s3://region.elasticmapreduce/bootstrap-actions/configure-hbase` como, *region* onde está a região na qual você está lançando seu cluster. HBase
Essa ação de bootstrap modifica o arquivo `/home/hadoop/conf/hbase-site.xml` de configuração no HBase cluster. A ação bootstrap só pode ser executada quando o HBase cluster é iniciado.
Para obter mais informações sobre as configurações do HBase site que você pode definir, consulte [Configuração padrão](http://hbase.apache.org/book.html#config.files) na HBase documentação.
Defina a ação de `configure-hbase` bootstrap ao iniciar o HBase cluster e especifique os valores a `hbase-site.xml` serem alterados.
**Para especificar configurações individuais HBase do site usando o AWS CLI**
+ Para alterar a `hbase.hregion.max.filesize` configuração, digite o seguinte comando e *myKey* substitua pelo nome do seu par de chaves do Amazon EC2.
**nota**
Os caracteres de continuação de linha do Linux (\$1) são incluídos para facilitar a leitura. Eles podem ser removidos ou usados em comandos do Linux. No Windows, remova-os ou substitua-os por um sinal de interpolação (^).
```
aws emr create-cluster --name "Test cluster" --ami-version 3.3 \
--applications Name=Hue Name=Hive Name=Pig Name=HBase \
--use-default-roles --ec2-attributes KeyName=myKey \
--instance-type c1.xlarge --instance-count 3 --termination-protected \
--bootstrap-actions Path=s3://elasticmapreduce/bootstrap-actions/configure-hbase,Args=["-s","hbase.hregion.max.filesize=52428800"]
```
**Para especificar as configurações do HBase site com um arquivo XML usando o AWS CLI**
1. Crie uma versão personalizada de `hbase-site.xml`. Seu arquivo personalizado deve ser um XML válido. Para reduzir a chance de introduzir erros, comece com a cópia padrão do`hbase-site.xml`, localizada no nó HBase principal do Amazon EMR em`/home/hadoop/conf/hbase-site.xml`, e edite uma cópia desse arquivo em vez de criar um arquivo do zero. Você pode dar um novo nome para o seu novo arquivo ou manter `hbase-site.xml`.
1. Carregue seu arquivo `hbase-site.xml` personalizado em um bucket do Amazon S3. Ele deve ter permissões definidas para que a AWS conta que executa o cluster possa acessar o arquivo. Se a AWS conta que está lançando o cluster também possuir o bucket do Amazon S3, ela terá acesso.
1. Defina a ação de bootstrap **configure-hbase** ao iniciar o HBase cluster e inclua a localização do seu arquivo personalizado. `hbase-site.xml` O exemplo a seguir define os valores de configuração do HBase site para aqueles especificados no arquivo`s3://amzn-s3-demo-bucket/my-hbase-site.xml`. Digite o comando a seguir, *myKey* substitua pelo nome do seu par de chaves do EC2 e *amzn-s3-demo-bucket* substitua pelo nome do seu bucket do Amazon S3.
**nota**
Os caracteres de continuação de linha do Linux (\$1) são incluídos para facilitar a leitura. Eles podem ser removidos ou usados em comandos do Linux. No Windows, remova-os ou substitua-os por um sinal de interpolação (^).
```
aws emr create-cluster --name "Test cluster" --ami-version 3.3 \
--applications Name=Hue Name=Hive Name=Pig Name=HBase \
--use-default-roles --ec2-attributes KeyName=myKey \
--instance-type c1.xlarge --instance-count 3 --termination-protected \
--bootstrap-actions Path=s3://elasticmapreduce/bootstrap-actions/configure-hbase,Args=["--site-config-file","s3://amzn-s3-demo-bucket/config.xml"]
```
Se você especificar mais de uma opção para personalizar a HBase operação, deverá prefixar cada par de valores-chave com uma `-s` opção, conforme mostrado no exemplo a seguir:
```
--bootstrap-actions s3://elasticmapreduce/bootstrap-actions/configure-hbase,Args=["-s","zookeeper.session.timeout=60000"]
```
Com o proxy definido e a conexão SSH aberta, você pode visualizar a HBase interface do usuário abrindo uma janela do navegador com http: //:60010/master-status*master-public-dns-name*, onde está *master-public-dns-name* o endereço DNS público do nó principal no cluster. HBase
Você pode visualizar os HBase registros atuais usando SSH para se conectar ao nó principal e navegar até o `mnt/var/log/hbase` diretório. Esses logs não estão disponíveis depois que o cluster é encerrado, a menos que você habilite o registro em log no Amazon S3 quando o cluster for iniciado.
## Backup e restauração HBase
O Amazon EMR fornece a capacidade de fazer backup de seus HBase dados no Amazon S3, manualmente ou em uma programação automatizada. Você pode executar backups completos e incrementais. Depois de ter uma versão de backup dos HBase dados, você pode restaurar essa versão em um HBase cluster. Você pode restaurar em um HBase cluster que esteja em execução no momento ou iniciar um novo cluster pré-preenchido com dados de backup.
Durante o processo de backup, HBase continua executando comandos de gravação. Embora isso garanta que o cluster permanecerá disponível durante o backup, existe o risco de inconsistência entre os dados que estão sendo copiados para backup e quaisquer operações de gravação que estejam sendo executadas em paralelo. Para entender as inconsistências que podem surgir, é preciso considerar que HBase distribui as operações de gravação entre os nós em seu cluster. Se uma operação de gravação acontecer depois que um nó específico for sondado, esses dados não serão incluídos no arquivamento de backup. Você pode até descobrir que gravações anteriores no HBase cluster (enviadas para um nó que já foi pesquisado) podem não estar no arquivo de backup, enquanto gravações posteriores (enviadas para um nó antes de ser pesquisado) estão incluídas.
Se for necessário um backup consistente, você deverá pausar as gravações HBase durante a parte inicial do processo de backup, a sincronização entre os nós. Isso pode ser feito especificando o parâmetro `--consistent` ao solicitar um backup. Com esse parâmetro, as gravações durante esse período são enfileiradas e executadas logo após a conclusão da sincronização. Você também pode agendar backups recorrentes, que resolvem quaisquer inconsistências com o passar do tempo, conforme os dados perdidos em uma passagem são copiados para backup na passagem seguinte.
Ao fazer backup HBase dos dados, você deve especificar um diretório de backup diferente para cada cluster. Uma maneira fácil de fazer isso é usar o identificador de cluster como parte do caminho especificado para o diretório de backup. Por exemplo, .`s3://amzn-s3-demo-bucket/backups/j-3AEXXXXXX16F2` Isso garante que qualquer backup incremental futuro faça referência ao HBase cluster correto.
Quando você estiver pronto para excluir arquivos de backup antigos que não são mais necessários, recomendamos que você primeiro faça um backup completo dos seus HBase dados. Isso garante que todos os dados sejam preservados e fornece uma base para futuros backups incrementais. Terminado o backup completo, você pode navegar até o local do backup e excluir manualmente os arquivos de backup antigos.
O processo HBase de backup usa o S3 DistCp para a operação de cópia, que tem certas limitações em relação ao espaço de armazenamento temporário de arquivos.
### Faça backup e restaure HBase usando o console
O console oferece a capacidade de iniciar um novo cluster e preenchê-lo com dados de um HBase backup anterior. Ele também permite programar backups incrementais periódicos dos HBase dados. Funcionalidades adicionais de backup e restauração, como a capacidade de restaurar dados para um cluster já em execução, fazer backups manuais e agendar backups completos automatizados, estão disponíveis usando a CLI.
**Para preencher um novo cluster com HBase dados arquivados usando o console**
1. Navegue até o novo console do Amazon EMR e selecione **Alternar para o console antigo** na navegação lateral. Para obter mais informações sobre o que esperar ao alternar para o console antigo, consulte [Usar o console antigo](https://docs.aws.amazon.com/emr/latest/ManagementGuide/whats-new-in-console.html#console-opt-in).
1. Selecione **Criar cluster**.
1. Na seção **Configuração de software**, para **Aplicativos adicionais**, escolha **Configurar **HBase**e adicionar**.
1. Na caixa de diálogo **Add Application (Adicionar aplicativo)**, marque **Restore From Backup (Restaurar a partir do backup)**.
1. Em **Local do Backup**, especifique o local do backup a ser carregado no novo HBase cluster. Este deve ser um URL do Amazon S3; no formato `s3://amzn-s3-demo-bucket/backups/`.
1. Para **Backup Version (Versão de backup)**, você tem a opção de especificar o nome de uma versão de backup a ser carregada, definindo um valor. Se você não definir um valor para **Versão de backup**, o Amazon EMR carregará o backup mais recente no local especificado.
1. Escolha **Add (Adicionar)** e continue para criar o cluster com outras opções, conforme desejado.
**Para agendar backups automatizados de HBase dados usando o console**
1. Na seção **Configuração de software**, para **Aplicativos adicionais**, escolha **Configurar **HBase**e adicionar**.
1. Escolha **Schedule Regular Backups (Programar backups regulares)**.
1. Especifica se os backups devem ser consistentes. Um backup consistente é aquele que pausa operações de gravação durante o estágio de backup inicial, a sincronização entre nós. Qualquer operação de gravação pausada é colocada em uma fila e retomada quando a sincronização é concluída.
1. Defina com que frequência os backups devem ocorrer, inserindo um número para **Backup Frequency (Frequência de backup)** e escolhendo **Days (Dias)**, **Hours (Horas)** ou **Minutes (Minutos)**. O primeiro backup automatizado que é executado é um backup completo. Depois disso, o Amazon EMR salva backups incrementais, com base no horário que você especificar.
1. Especifique o local no Amazon S3 em que os backups devem ser armazenados. O backup de cada HBase cluster deve ser feito em um local separado no Amazon S3 para garantir que os backups incrementais sejam calculados corretamente.
1. Especifique quando o primeiro backup deve ocorrer, definindo um valor para **Backup Start Time (Hora de início do backup)**. Você pode definir isso como `now`, o que faz com que o primeiro backup comece assim que o cluster estiver em execução, ou inserir uma data e uma hora no [formato ISO](http://www.w3.org/TR/NOTE-datetime). Por exemplo, 2013-09-26T20:00Z, define a hora de início como 26 de setembro de 2013 às 8 p.m. UTC.
1. Escolha **Adicionar**.
1. Continue com a criação do cluster, com outras opções conforme desejado.
## Monitor HBase com CloudWatch
O Amazon EMR relata três métricas CloudWatch que você pode usar para monitorar seus HBase backups. Essas métricas são enviadas CloudWatch em intervalos de cinco minutos e são fornecidas gratuitamente.
| Métrica | Description |
| --- | --- |
| HBaseBackupFailed | Se o último backup falhou. É definido como 0 por padrão e atualizado para 1 se a tentativa de backup anterior falhou. Essa métrica é relatada somente para HBase clusters. Caso de uso: monitorar HBase backups Unidades: *Contagem* |
| HBaseMostRecentBackupDuration | O tempo que o backup anterior levou para ser concluído. Essa métrica é definida independentemente de o último backup ter sido bem-sucedido ou ter falhado. Enquanto o backup está sendo processado, essa métrica retorna o número de minutos desde o início do backup. Essa métrica é relatada somente para HBase clusters. Caso de uso: Monitorar HBase backups Unidade: *minutos* |
| HBaseTimeSinceLastSuccessfulBackup | O número de minutos decorridos após o início do último HBase backup bem-sucedido em seu cluster. Essa métrica é relatada somente para HBase clusters. Caso de uso: monitorar HBase backups Unidade: *minutos* |
## Configurar o Ganglia para HBase
Você configura o Ganglia para HBase usar a ação **configure-hbase-for-ganglia**bootstrap. Essa ação de bootstrap é configurada HBase para publicar métricas no Ganglia.
Você deve configurar o HBase Ganglia ao iniciar o cluster; os relatórios do Ganglia não podem ser adicionados a um cluster em execução.
O Ganglia também armazena arquivos de log no servidor em `/mnt/var/log/ganglia/rrds`. Se você tiver configurado o cluster para manter a persistência dos arquivos de log em um bucket do Amazon S3, os arquivos de log do Ganglia serão mantidos lá também.
Para iniciar um cluster com o Ganglia for HBase, use a ação **configure-hbase-for-ganglia**bootstrap conforme mostrado no exemplo a seguir.
**nota**
Os caracteres de continuação de linha do Linux (\$1) são incluídos para facilitar a leitura. Eles podem ser removidos ou usados em comandos do Linux. No Windows, remova-os ou substitua-os por um sinal de interpolação (^).
```
aws emr create-cluster --name "Test cluster" --ami-version 3.3 \
--applications Name=Hue Name=Hive Name=Pig Name=HBase Name=Ganglia \
--use-default-roles --ec2-attributes KeyName=myKey \
--instance-type c1.xlarge --instance-count 3 --termination-protected \
--bootstrap-actions Path=s3://elasticmapreduce/bootstrap-actions/configure-hbase-for-ganglia
```
Depois que o cluster é executado com o Ganglia configurado, você pode acessar os gráficos e relatórios do Ganglia usando a interface gráfica em execução no nó principal.
# Detalhes da aplicação Pig para versões anteriores da AMI do Amazon EMR
## Versões compatíveis do Pig
A versão do Pig que você pode adicionar ao cluster depende da versão da AMI do Amazon EMR e da versão do Hadoop em uso. A tabela abaixo mostra quais versões do AMI e do Hadoop são compatíveis com as diferentes versões do Pig. Recomendamos que você use a versão mais recente do Pig para aproveitar as melhorias de desempenho e as novas funcionalidades.
Quando você usa a API para instalar o Pig, a versão padrão é usada, a menos que você especifique `--pig-versions` como argumento para a etapa que carrega o Pig no cluster durante a chamada para. [RunJobFlow](https://docs.aws.amazon.com/ElasticMapReduce/latest/API/API_RunJobFlow.html)
| Versão do Pig | AMI version | Parâmetros de configuração | Detalhes da versão do Pig |
| --- | --- | --- | --- |
| 0.12.0[Notas da versão](http://pig.apache.org/releases.html#14+October%2C+2013%3A+release+0.12.0+available)[Documentação](http://pig.apache.org/docs/r0.12.0/) | 3.1.0 e posterior | `--ami-version 3.1` `--ami-version 3.2` `--ami-version 3.3` | Adiciona suporte para: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/emr/latest/ReleaseGuide/emr-3x-pig.html) |
| 0.11.1.1[Notas da versão](http://pig.apache.org/releases.html#1+April%2C+2013%3A+release+0.11.1+available)[Documentação](http://pig.apache.org/docs/r0.11.1/) | 2.2 e posterior | `--pig-versions 0.11.1.1` `--ami-version 2.2` | Melhora o desempenho do comando LOAD PigStorage se a entrada residir no Amazon S3. |
| 0.11.1[Notas da versão](http://pig.apache.org/releases.html#1+April%2C+2013%3A+release+0.11.1+available)[Documentação](http://pig.apache.org/docs/r0.11.1/) | 2.2 e posterior | `--pig-versions 0.11.1` `--ami-version 2.2` | Adiciona suporte para JDK 7, Hadoop 2, funções definidas pelo usuário do Groovy, SchemaTuple otimização, novos operadores e muito mais. Para obter mais informações, consulte [Log de alterações do Pig 0.11.1](http://svn.apache.org/repos/asf/pig/tags/release-0.11.1/CHANGES.txt). |
| 0.9.2.2[Notas da versão](http://pig.apache.org/releases.html#22+January%2C+2012%3A+release+0.9.2+available)[Documentação](http://pig.apache.org/docs/r0.9.2/index.html) | 2.2 e posterior | `--pig-versions 0.9.2.2` `--ami-version 2.2` | Adiciona suporte para Hadoop 1.0.3. |
| 0.9.2.1[Notas da versão](http://pig.apache.org/releases.html#22+January%2C+2012%3A+release+0.9.2+available)[Documentação](http://pig.apache.org/docs/r0.9.2/index.html) | 2.2 e posterior | `--pig-versions 0.9.2.1` `--ami-version 2.2` | Adiciona suporte para MapR. |
| 0.9.2[Notas da versão](http://pig.apache.org/releases.html#22+January%2C+2012%3A+release+0.9.2+available)[Documentação](http://pig.apache.org/docs/r0.9.2/index.html) | 2.2 e posterior | `--pig-versions 0.9.2` `--ami-version 2.2` | Inclui várias melhorias no desempenho e correções de erros. Para obter informações completas sobre as alterações do Pig 0.9.2, acesse o [Log de alterações do Pig 0.9.2](http://svn.apache.org/repos/asf/pig/tags/release-0.9.2/CHANGES.txt). |
| 0.9.1[Notas da versão](http://pig.apache.org/releases.html#5+October%2C+2011%3A+release+0.9.1+available)[Documentação](http://pig.apache.org/docs/r0.9.1/) | 2,0 | `--pig-versions 0.9.1` `--ami-version 2.0` |
| 0.6[Notas da versão](http://pig.apache.org/releases.html#1+March%2C+2010%3A+release+0.6.0+available) | 1,0 | `--pig-versions 0.6` `--ami-version 1.0` |
| 0.3[Notas da versão](http://pig.apache.org/releases.html#25+June%2C+2009%3A+release+0.3.0+available) | 1,0 | `--pig-versions 0.3` `--ami-version 1.0` |
## Detalhes da versão do Pig
O Amazon EMR é compatível com determinadas versões do Pig que podem ter patches adicionais do Amazon EMR aplicados. Você pode configurar qual versão do Pig será executada em clusters do Amazon EMR. Para obter mais informações sobre como fazer isso, consulte [Apache Pig](emr-pig.md). As seções a seguir descrevem diferentes versões do Pig e os patches aplicados às versões carregadas no Amazon EMR.
### Patches do Pig
Esta seção descreve os patches personalizados aplicados nas versões do Pig disponíveis com o Amazon EMR.
#### Patches do Pig 0.11.1.1
A versão do Amazon EMR do Pig 0.11.1.1 é uma versão de manutenção que melhora o desempenho do comando LOAD PigStorage se a entrada residir no Amazon S3.
#### Patches do Pig 0.11.1
A versão 0.11.1 do pig do Amazon EMR contém todas as atualizações fornecidas pela Apache Software Foundation e os patches cumulativos do Amazon EMR do Pig versão 0.9.2.2. No entanto, não há novos patches específicos do Amazon EMR no Pig 0.11.1.
#### Patches do Pig 0.9.2
A Apache Pig 0.9.2 é uma versão de manutenção do Pig. A equipe do Amazon EMR aplicou os seguintes patches à versão 0.9.2 do Pig do Amazon EMR.
| Patch | Description |
| --- | --- |
| PIG-1429 | Adiciona o tipo de dados Boolean ao Pig como um tipo de dados de primeira classe. Para obter mais informações, acesse [https://issues.apache. org/jira/browse/PIG-1429](https://issues.apache.org/jira/browse/PIG-1429). **Status:** Confirmado **Fixed in Apache Pig Version (Corrigido no Apache Pig versão):** 0.10 |
| PIG-1824 | Suporte a módulos de importação na UDF do Jython. Para obter mais informações, acesse [https://issues.apache. org/jira/browse/PIG-1824](https://issues.apache.org/jira/browse/PIG-1824). **Status:** Confirmado **Fixed in Apache Pig Version (Corrigido no Apache Pig versão):** 0.10 |
| PIG-2010 | Pacote registrado JARs no cache distribuído. Para obter mais informações, acesse [https://issues.apache. org/jira/browse/PIG-2010.](https://issues.apache.org/jira/browse/PIG-2010) **Status:** Confirmado **Fixed in Apache Pig Version (Corrigido no Apache Pig versão):** 0.11 |
| PIG-2456 | Adiciona um arquivo \$1 /.pigbootup onde o usuário pode especificar instruções padrão do Pig. Para obter mais informações, acesse [https://issues.apache. org/jira/browse/PIG-2456](https://issues.apache.org/jira/browse/PIG-2456). **Status:** Confirmado **Fixed in Apache Pig Version (Corrigido no Apache Pig versão):** 0.11 |
| PIG-2623 | Support o uso de caminhos do Amazon S3 para se registrar. UDFs Para obter mais informações, acesse [https://issues.apache. org/jira/browse/PIG-2623](https://issues.apache.org/jira/browse/PIG-2623). **Status:** Confirmado **Fixed in Apache Pig Version (Corrigido no Apache Pig versão):** 0.10, 0.11 |
#### Patches do Pig 0.9.1
A equipe do Amazon EMR aplicou os seguintes patches à versão 0.9.1 do Pig do Amazon EMR.
| Patch | Description |
| --- | --- |
| Oferece suporte a arquivos JAR e scripts do Pig em dfs | Adiciona suporte para a execução de scripts e o registro de arquivos JAR armazenados em HDFS, no Amazon S3 ou em outros sistemas de arquivos distribuídos. Para obter mais informações, acesse [https://issues.apache. org/jira/browse/PIG-1505](https://issues.apache.org/jira/browse/PIG-1505). **Status:** Confirmado **Fixed in Apache Pig Version (Corrigido no Apache Pig versão)** 0.8.0 |
| Oferece suporte a vários sistemas de arquivos no Pig | Adiciona suporte a scripts do Pig para a leitura de dados de um sistema de arquivos e gravação em outro sistema. Para obter mais informações, acesse [https://issues.apache. org/jira/browse/PIG-1564](https://issues.apache.org/jira/browse/PIG-1564). **Status:** Não confirmado **Fixed in Apache Pig Version (Corrigido no Apache Pig versão)** n/a |
| Adicionar data, hora e string do Piggybank UDFs | Adicione data e hora e string UDFs para oferecer suporte a scripts personalizados do Pig. Para obter mais informações, acesse [https://issues.apache. org/jira/browse/PIG-1565](https://issues.apache.org/jira/browse/PIG-1565). **Status:** Não confirmado **Fixed in Apache Pig Version (Corrigido no Apache Pig versão)** n/a |
## Clusters interativos e em lote no Pig
O Amazon EMR permite que você execute scripts do Pig em dois modos:
+ Interativo
+ Lote
Ao iniciar um cluster de longa execução usando o console ou o AWS CLI, você pode se conectar usando **ssh** o nó principal como usuário do Hadoop e usar o shell Grunt para desenvolver e executar seus scripts Pig de forma interativa. Usar o Pig no modo interativo permite que você revise o script do Pig com mais facilidade do que no modo em lote. Depois de revisar o script do Pig no modo interativo com êxito, você pode carregar o script para o Amazon S3 e executar o script no modo em lote na produção. Você também pode enviar comandos do Pig interativamente em um cluster em execução para analisar e transformar os dados conforme necessário.
No modo em lote, você carrega o script do Pig para o Amazon S3 e, em seguida, envia o trabalho para o cluster como uma etapa. As etapas do Pig podem ser enviadas para um cluster de execução prolongada ou um cluster temporário.
# Detalhes de aplicações do Spark com versões anteriores da AMI do Amazon EMR
## Usar o Spark interativamente ou no modo em lote
O Amazon EMR permite a execução de aplicações do Spark em dois modos:
+ Interativo
+ Lote
Ao iniciar um cluster de longa execução usando o console ou o AWS CLI, você pode se conectar usando SSH ao nó principal como usuário do Hadoop e usar o shell do Spark para desenvolver e executar seus aplicativos Spark de forma interativa. Usar o Spark interativamente permite criar protótipos ou testar aplicativos Spark com mais facilidade do que em um ambiente em lote. Depois de revisar com sucesso a aplicação do Spark no modo interativo, você pode colocar a aplicação do JAR ou o programa do Python do sistema de arquivos local no nó principal do cluster do Amazon S3. Em seguida, você pode enviar o aplicativo como um fluxo de trabalho em lote.
No modo em lote, carregue o script do Spark no Amazon S3 ou no sistema de arquivos do nó principal local e, em seguida, envie o trabalho ao cluster como uma etapa. As etapas do Spark podem ser enviadas a um cluster de longa execução ou a um cluster transitório.
## Criar um cluster com o Spark instalado
**Para executar um cluster com o Spark instalado usando o console**
1. Navegue até o novo console do Amazon EMR e selecione **Alternar para o console antigo** na navegação lateral. Para obter mais informações sobre o que esperar ao alternar para o console antigo, consulte [Usar o console antigo](https://docs.aws.amazon.com/emr/latest/ManagementGuide/whats-new-in-console.html#console-opt-in).
1. Selecione **Criar cluster**.
1. Para **Software Configuration (Configuração do software)**, escolha a versão da AMI de que você precisa.
1. Para **Applications to be installed (Aplicativos a serem instalados)**, escolha **Spark** na lista e depois escolha **Configure and add (Configurar e adicionar)**.
1. Adicione argumentos para alterar a configuração do Spark conforme desejado. Para obter mais informações, consulte [Configurar o Spark](#emr-3x-spark-configure). Escolha **Adicionar**.
1. Selecione outras opções conforme necessário e escolha **Create cluster (Criar cluster)**.
O seguinte exemplo mostra como criar um cluster com o Spark usando Java:
```
AmazonElasticMapReduceClient emr = new AmazonElasticMapReduceClient(credentials);
SupportedProductConfig sparkConfig = new SupportedProductConfig()
.withName("Spark");
RunJobFlowRequest request = new RunJobFlowRequest()
.withName("Spark Cluster")
.withAmiVersion("3.11.0")
.withNewSupportedProducts(sparkConfig)
.withInstances(new JobFlowInstancesConfig()
.withEc2KeyName("myKeyName")
.withInstanceCount(1)
.withKeepJobFlowAliveWhenNoSteps(true)
.withMasterInstanceType("m3.xlarge")
.withSlaveInstanceType("m3.xlarge")
);
RunJobFlowResult result = emr.runJobFlow(request);
```
## Configurar o Spark
Você configura o Spark ao criar um cluster executando a ação bootstrap localizada no [awslabs/emr-bootstrap-actions/sparkrepositório no Github](https://github.com/awslabs/emr-bootstrap-actions/tree/master/spark). Para saber quais argumentos a ação de bootstrap aceita, consulte o arquivo [LEIAME](https://github.com/aws-samples/emr-bootstrap-actions/blob/master/spark/examples/README.md) nesse repositório. A ação de bootstrap configura propriedades no arquivo `$SPARK_CONF_DIR/spark-defaults.conf`. Para obter mais informações sobre configurações, consulte o tópico Configuração do Spark na documentação do Spark. Você pode substituir "latest" (mais recente) na URL a seguir pelo número da versão do Spark que você está instalando, por exemplo, `2.2.0` [http://spark.apache.org/docs/latest/configuration.html](http://spark.apache.org/docs/latest/configuration.html).
Você também pode configurar o Spark dinamicamente no momento do envio de cada aplicativo. Uma configuração para maximizar automaticamente a alocação de recursos para um executor está disponível usando o arquivo de configuração `spark`. Para obter mais informações, consulte [Substituir as definições de configuração padrão do Spark](#emr-3x-spark-dynamic-configuration).
### Alterar as configurações padrão do Spark
O seguinte exemplo mostra como criar um cluster com o `spark.executor.memory` definido como 2G usando a AWS CLI.
**nota**
Os caracteres de continuação de linha do Linux (\$1) são incluídos para facilitar a leitura. Eles podem ser removidos ou usados em comandos do Linux. No Windows, remova-os ou substitua-os por um sinal de interpolação (^).
```
aws emr create-cluster --name "Spark cluster" --ami-version 3.11.0 \
--applications Name=Spark, Args=[-d,spark.executor.memory=2G] --ec2-attributes KeyName=myKey \
--instance-type m3.xlarge --instance-count 3 --use-default-roles
```
### Enviar trabalhos para o Spark
Para enviar trabalhos a um cluster, use uma etapa para executar o script `spark-submit` no seu cluster do EMR. Adicione a etapa usando o `addJobFlowSteps` método em [AmazonElasticMapReduceClient](https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/com/amazonaws/services/elasticmapreduce/AmazonElasticMapReduceClient.html):
```
AWSCredentials credentials = new BasicAWSCredentials(accessKey, secretKey);
AmazonElasticMapReduceClient emr = new AmazonElasticMapReduceClient(credentials);
StepFactory stepFactory = new StepFactory();
AddJobFlowStepsRequest req = new AddJobFlowStepsRequest();
req.withJobFlowId("j-1K48XXXXXXHCB");
List stepConfigs = new ArrayList();
StepConfig sparkStep = new StepConfig()
.withName("Spark Step")
.withActionOnFailure("CONTINUE")
.withHadoopJarStep(stepFactory.newScriptRunnerStep("/home/hadoop/spark/bin/spark-submit","--class","org.apache.spark.examples.SparkPi","/home/hadoop/spark/lib/spark-examples-1.3.1-hadoop2.4.0.jar","10"));
stepConfigs.add(sparkStep);
req.withSteps(stepConfigs);
AddJobFlowStepsResult result = emr.addJobFlowSteps(req);
```
### Substituir as definições de configuração padrão do Spark
Você pode querer substituir valores de configuração padrão do Spark para cada aplicativo. Você pode fazer isso ao enviar aplicativos usando uma etapa, que transmite essencialmente opções para `spark-submit`. Por exemplo, você pode querer alterar a memória alocada para um processo de executor modificando `spark.executor.memory`. Você pode fornecer ao switch `--executor-memory` um argumento semelhante ao seguinte:
```
/home/hadoop/spark/bin/spark-submit --executor-memory 1g --class org.apache.spark.examples.SparkPi /home/hadoop/spark/lib/spark-examples*.jar 10
```
Da mesma forma, você pode ajustar `--executor-cores` e `--driver-memory`. Em uma etapa, você forneceria os seguintes argumentos para a etapa:
```
--executor-memory 1g --class org.apache.spark.examples.SparkPi /home/hadoop/spark/lib/spark-examples*.jar 10
```
Você também pode ajustar as configurações que não possam não ter uma opção interna usando `--conf`. Para obter mais informações sobre outras configurações que são ajustáveis, consulte o tópico [Dynamically loading Spark properties](https://spark.apache.org/docs/latest/configuration.html#dynamically-loading-spark-properties) na documentação do Apache Spark.
# Diferenças de DistCp utilidade do S3 com versões anteriores da AMI do Amazon EMR
## DistCp Versões do S3 suportadas no Amazon EMR
As seguintes versões do S3 são suportadas nas DistCp versões da AMI do Amazon EMR. DistCpAs versões S3 posteriores à 1.0.7 são encontradas diretamente nos clusters. Use o JAR em `/home/hadoop/lib` para obter os recursos mais recentes.
| Versão | Description | Data de lançamento |
| --- | --- | --- |
| 1.0.8 | Adiciona as opções --appendToLastFile, --requirePreviousManifeste --storageClass. | 3 de janeiro de 2014 |
| 1.0.7 | Adiciona a opção --s3ServerSideEncryption. | 2 de maio de 2013 |
| 1.0.6 | Adiciona a opção --s3Endpoint. | 6 de agosto de 2012 |
| 1.0.5 | Melhora a capacidade de especificar qual versão do S3 DistCp deve ser executada. | 27 de junho de 2012 |
| 1.0.4 | Melhora a opção --deleteOnSuccess. | 19 de junho de 2012 |
| 1.0.3 | Adiciona suporte às opções --numberFiles e --startingIndex. | 12 de junho de 2012 |
| 1.0.2 | Melhora a nomeação de arquivos ao usar grupos. | 6 de junho de 2012 |
| 1.0.1 | Lançamento inicial do S3DistCp. | 19 de janeiro de 2012 |
## Adicionar uma etapa de DistCp cópia do S3 a um cluster
Para adicionar uma etapa de DistCp cópia do S3 a um cluster em execução, digite o seguinte comando, *j-3GYXXXXXX9IOK* substitua pelo ID do cluster e *amzn-s3-demo-bucket* substitua pelo nome do bucket do Amazon S3.
**nota**
Os caracteres de continuação de linha do Linux (\$1) são incluídos para facilitar a leitura. Eles podem ser removidos ou usados em comandos do Linux. No Windows, remova-os ou substitua-os por um sinal de interpolação (^).
```
aws emr add-steps --cluster-id j-3GYXXXXXX9IOK \
--steps Type=CUSTOM_JAR,Name="S3DistCp step",Jar=/home/hadoop/lib/emr-s3distcp-1.0.jar,\
Args=["--s3Endpoint,s3-eu-west-1.amazonaws.com",\
"--src,s3://amzn-s3-demo-bucket/logs/j-3GYXXXXXX9IOJ/node/",\
"--dest,hdfs:///output",\
"--srcPattern,.*[a-zA-Z,]+"]
```
**Example Carregar CloudFront registros da Amazon no HDFS**
Este exemplo carrega CloudFront os logs da Amazon no HDFS adicionando uma etapa a um cluster em execução. No processo, ele muda o formato de compactação de Gzip (o padrão do CloudFront) para LZO. Isso é útil, pois dados compactados usando LZO podem ser divididos em vários mapas conforme são descompactados, portanto, você não precisa aguardar até que a compactação seja concluída, como ocorre com o Gzip. Isso proporciona uma melhor performance quando você analisa os dados usando o Amazon EMR. Esse exemplo também melhora a performance ao usar a expressão regular especificada na opção `--groupBy` para combinar todos os logs de uma determinada hora em um único arquivo. Os clusters do Amazon EMR são mais eficientes quando processam alguns arquivos grandes com compactação LZO do que quando processam vários arquivos pequenos com compactação Gzip. Para dividir arquivos LZO, você deve indexá-los e usar a biblioteca de terceiros hadoop-lzo.
Para carregar CloudFront os logs da Amazon no HDFS, digite o seguinte comando, *j-3GYXXXXXX9IOK* substitua pelo ID do cluster e *amzn-s3-demo-bucket* substitua pelo nome do bucket do Amazon S3.
Os caracteres de continuação de linha do Linux (\$1) são incluídos para facilitar a leitura. Eles podem ser removidos ou usados em comandos do Linux. No Windows, remova-os ou substitua-os por um sinal de interpolação (^).
```
aws emr add-steps --cluster-id j-3GYXXXXXX9IOK \
--steps Type=CUSTOM_JAR,Name="S3DistCp step",Jar=/home/hadoop/lib/emr-s3distcp-1.0.jar,\
Args=["--src,s3://amzn-s3-demo-bucket/cf","--dest,hdfs:///local",\
"--groupBy,.*XABCD12345678.([0-9]+-[0-9]+-[0-9]+-[0-9]+).*",\
"--targetSize,128",
"--outputCodec,lzo","--deleteOnSuccess"]
```
Considere o caso no qual o exemplo anterior é executado com os seguintes arquivos de log do CloudFront .
```
s3://amzn-s3-demo-bucket/cf/XABCD12345678.2012-02-23-01.HLUS3JKx.gz
s3://amzn-s3-demo-bucket/cf/XABCD12345678.2012-02-23-01.I9CNAZrg.gz
s3://amzn-s3-demo-bucket/cf/XABCD12345678.2012-02-23-02.YRRwERSA.gz
s3://amzn-s3-demo-bucket/cf/XABCD12345678.2012-02-23-02.dshVLXFE.gz
s3://amzn-s3-demo-bucket/cf/XABCD12345678.2012-02-23-02.LpLfuShd.gz
```
O S3 DistCp copia, concatena e compacta os arquivos nos dois arquivos a seguir, onde o nome do arquivo é determinado pela correspondência feita pela expressão regular.
```
hdfs:///local/2012-02-23-01.lzo
hdfs:///local/2012-02-23-02.lzo
```