

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á.

# Tutorial: conceitos básicos do Amazon EMR
<a name="emr-gs"></a>

Examine um fluxo de trabalho para configurar rapidamente um cluster do Amazon EMR e executar uma aplicação do Spark.

## Configuração do cluster do Amazon EMR
<a name="emr-getting-started-overview"></a>

Com o Amazon EMR, é possível configurar um cluster para processar e analisar dados com estruturas de big data em apenas alguns minutos. Este tutorial mostra como iniciar um cluster de amostra usando o Spark e como executar um PySpark script simples armazenado em um bucket do Amazon S3. Ele abrange tarefas essenciais do Amazon EMR em três categorias principais de fluxo de trabalho: planejar e configurar, gerenciar e limpar.

Você encontrará links para tópicos mais detalhados à medida que avança no tutorial e obterá ideias para etapas adicionais na seção [Próximas etapas](#emr-gs-next-steps). Se você tiver perguntas ou dúvidas, entre em contato com a equipe do Amazon EMR em nosso [fórum de discussão](https://forums.aws.amazon.com/forum.jspa?forumID=52).

![Diagrama para o fluxo de trabalho do Amazon EMR que descreve as três principais categorias de fluxo de trabalho: planejar e configurar, gerenciar e limpar.](http://docs.aws.amazon.com/pt_br/emr/latest/ManagementGuide/images/emr-workflow.png)


**Pré-requisitos**
+ Antes de iniciar um cluster do Amazon EMR, certifique-se de concluir as tarefas em [Antes de configurar o Amazon EMR](emr-setting-up.md).

**Custo**
+ O exemplo de cluster que você criar será executado em um ambiente dinâmico. O cluster acumula cobranças mínimas. Para evitar cobranças adicionais, certifique-se de concluir as tarefas de limpeza na última etapa deste tutorial. As cobranças são acumuladas à taxa por segundo, de acordo com os preços do Amazon EMR. As cobranças também variam com base na região. Para obter mais informações, consulte [Preço do Amazon EMR](https://aws.amazon.com/emr/pricing).
+ Cobranças mínimas podem ser acumuladas para arquivos pequenos armazenados no Amazon S3. Algumas ou todas as cobranças do Amazon S3 podem ser dispensadas se você estiver dentro dos limites de uso do AWS nível gratuito. Para obter mais informações, consulte [Preço do Amazon S3](https://aws.amazon.com/s3/pricing) e [nível gratuito da AWS](https://aws.amazon.com/free/).

## Etapa 1: configurar recursos de dados e iniciar um cluster do Amazon EMR
<a name="emr-getting-started-plan-and-configure"></a>

### Preparação do armazenamento para o Amazon EMR
<a name="emr-getting-started-prepare-storage"></a>

Ao usar o Amazon EMR, é possível escolher entre uma variedade de sistemas de arquivos para armazenar dados de entrada, dados de saída e arquivos de log. Neste tutorial, você usa o EMRFS para armazenar dados em um bucket do S3. O EMRFS é uma implementação do sistema de arquivos do Hadoop que permite a leitura e a gravação de arquivos regulares no Amazon S3. Para obter mais informações, consulte [Como trabalhar com armazenamento e sistemas de arquivos com o Amazon EMR](emr-plan-file-systems.md).

Para criar um bucket para este tutorial, siga as instruções em [How do I create an S3 bucket?](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/create-bucket.html) no *Guia do usuário do console do Amazon Simple Storage Service*. Crie o bucket na mesma AWS região em que você planeja lançar seu cluster do Amazon EMR. Por exemplo, Oeste dos EUA (Oregon) us-west-2. 

Os buckets e as pastas usados ​​com o Amazon EMR têm as seguintes limitações:
+ Os nomes podem consistir em letras minúsculas, números, pontos (.) e hifens (-).
+ Os nomes não podem terminar em números.
+ O nome do bucket deve ser exclusivo *em todas as contas da AWS *.
+ Uma pasta de saída deve estar vazia.

### Preparação de uma aplicação com dados de entrada para o Amazon EMR
<a name="emr-getting-started-prepare-app"></a>

A maneira mais comum de preparar uma aplicação para o Amazon EMR é fazer o upload da aplicação e de seus dados de entrada para o Amazon S3. Em seguida, ao enviar o trabalho para o cluster, você especifica os locais do Amazon S3 para o script e para os dados.

Nesta etapa, você carrega um PySpark script de amostra no seu bucket do Amazon S3. Fornecemos um PySpark script para você usar. O script processa os dados de inspeção de estabelecimentos alimentícios e retorna um arquivo de resultados em seu bucket do S3. O arquivo de resultados lista os dez principais estabelecimentos com mais violações do tipo “vermelho”.

Você também carrega dados de entrada de amostra para o Amazon S3 para que o PySpark script seja processado. Os dados de entrada correspondem a uma versão modificada dos resultados de inspeções do Departamento de Saúde no Condado de King, em Washington, de 2006 a 2020. Para obter mais informações, consulte [King County Open Data: Food Establishment Inspection Data](https://data.kingcounty.gov/Health-Wellness/Food-Establishment-Inspection-Data/f29f-zza5). Não baixe os dados do restaurante para este tutorial diretamente do site de King County, porque é o arquivo é muito grande. Para ajudar a concluir o tutorial, fornecemos um download abaixo que tem um arquivo com menos registros. Confira a seguir exemplos de linhas do conjunto de dados.

```
name,inspection_result,inspection_closed_business,violation_type,violation_points
100 LB CLAM,Unsatisfactory,FALSE,BLUE,5
100 PERCENT NUTRICION,Unsatisfactory,FALSE,BLUE,5
7-ELEVEN #2361-39423A,Complete,FALSE,,0
```

**Para preparar o PySpark script de exemplo para o EMR**

1. Copie o código de exemplo abaixo em um novo arquivo no editor de sua preferência.

   ```
   import argparse
   
   from pyspark.sql import SparkSession
   
   def calculate_red_violations(data_source, output_uri):
       """
       Processes sample food establishment inspection data and queries the data to find the top 10 establishments
       with the most Red violations from 2006 to 2020.
   
       :param data_source: The URI of your food establishment data CSV, such as 's3://amzn-s3-demo-bucket/food-establishment-data.csv'.
       :param output_uri: The URI where output is written, such as 's3://amzn-s3-demo-bucket/restaurant_violation_results'.
       """
       with SparkSession.builder.appName("Calculate Red Health Violations").getOrCreate() as spark:
           # Load the restaurant violation CSV data
           if data_source is not None:
               restaurants_df = spark.read.option("header", "true").csv(data_source)
   
           # Create an in-memory DataFrame to query
           restaurants_df.createOrReplaceTempView("restaurant_violations")
   
           # Create a DataFrame of the top 10 restaurants with the most Red violations
           top_red_violation_restaurants = spark.sql("""SELECT name, count(*) AS total_red_violations 
             FROM restaurant_violations 
             WHERE violation_type = 'RED' 
             GROUP BY name 
             ORDER BY total_red_violations DESC LIMIT 10""")
   
           # Write the results to the specified output URI
           top_red_violation_restaurants.write.option("header", "true").mode("overwrite").csv(output_uri)
   
   if __name__ == "__main__":
       parser = argparse.ArgumentParser()
       parser.add_argument(
           '--data_source', help="The URI for you CSV restaurant data, like an S3 bucket location.")
       parser.add_argument(
           '--output_uri', help="The URI where output is saved, like an S3 bucket location.")
       args = parser.parse_args()
   
       calculate_red_violations(args.data_source, args.output_uri)
   ```

1. Salve o arquivo como `health_violations.py`.

1. Faça o upload de `health_violations.py` para o Amazon S3 no bucket criado para este tutorial. Para obter instruções, consulte [Fazer upload de um objeto para o bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html#uploading-an-object-bucket) no *Guia de conceitos básicos do Amazon Simple Storage Service*.

**Preparar os dados de entrada de exemplo para o EMR**

1. Faça o download do arquivo zip [food\_establishment\_data.zip](samples/food_establishment_data.zip).

1. Descompacte e salve `food_establishment_data.zip` como `food_establishment_data.csv` em sua máquina.

1. Faça o upload do arquivo CSV para o bucket do S3 criado para este tutorial. Para obter instruções, consulte [Fazer upload de um objeto para o bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html#uploading-an-object-bucket) no *Guia de conceitos básicos do Amazon Simple Storage Service*.

Para obter mais informações sobre como configurar dados para o EMR, consulte [Preparo dos dados de entrada para processamento com o Amazon EMR](emr-plan-input.md).

### Inicialização de um cluster do Amazon EMR
<a name="emr-getting-started-launch-sample-cluster"></a>

Após preparar um local de armazenamento e a aplicação, você poderá iniciar um cluster do Amazon EMR de exemplo. Nesta etapa, você inicia um cluster do Apache Spark usando a [versão mais recente do Amazon EMR](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-release-components.html).

------
#### [ Console ]

**Para iniciar um cluster com o Spark instalado usando o console**

1. [Faça login no e abra Console de gerenciamento da AWS o console do Amazon EMR em https://console.aws.amazon.com /emr.](https://console.aws.amazon.com/emr)

1. Em **EMR no EC2**, no painel de navegação esquerdo, escolha **Clusters** e depois **Criar cluster**.

1. Na página **Criar cluster**, observe os valores padrão para **Versão**, **Tipo de instância**, **Número de instâncias** e **Permissões**. Esses campos são preenchidos automaticamente com valores que funcionam para clusters de uso geral.

1. No campo **Nome do cluster**, insira um nome de cluster exclusivo para ajudá-lo a identificar seu cluster, como{{My first cluster}}. O nome do cluster não pode conter os caracteres <, >, $, \| ou ` (crase).

1. Em **Aplicações**, escolha a opção **Spark** para instalar o Spark em seu cluster.
**nota**  
Escolha as aplicações que você deseja em seu cluster do Amazon EMR antes de iniciar o cluster. Não é possível adicionar ou remover aplicações de um cluster após a inicialização.

1. Em **Logs do cluster**, marque a caixa de seleção Publicar logs específicos do cluster no Amazon S3. Substitua o valor do **local do Amazon S3** pelo bucket do Amazon S3 criado, seguido por **/logs**. Por exemplo, .**s3://amzn-s3-demo-bucket/logs** A adição de **/logs** cria uma nova pasta chamada “logs” em seu bucket, na qual o Amazon EMR pode copiar os arquivos de log do seu cluster.

1. Em **Configuração e permissões de segurança**, escolha seu **par de chaves do EC2**. **Na mesma seção, selecione o menu suspenso **Função de serviço para o Amazon EMR** e escolha EMR\_. DefaultRole** Em seguida, selecione a **função do IAM no menu suspenso do perfil da instância** e escolha **EC2EMR\_** \_. DefaultRole 

1. Escolha **Criar cluster** para iniciar o cluster e abrir a página de detalhes do cluster.

1. Veja o **Status** do cluster próximo ao nome do cluster. O status é alterado de **Iniciando** para **Em execução** e, em seguida, para **Aguardando**, conforme o Amazon EMR provisiona o cluster. Pode ser necessário escolher o ícone de atualização à direita ou atualizar seu navegador para visualizar as atualizações de status.

O status do cluster é alterado para **Aguardando** quando o cluster está ativo, em execução e pronto para aceitar trabalhos. Para obter mais informações sobre como ler o resumo do cluster, consulte [Exibição de status e detalhes do cluster do Amazon EMR](emr-manage-view-clusters.md). Para obter informações sobre o status do cluster, consulte [Noções básicas sobre o ciclo de vida do cluster](emr-overview.md#emr-overview-cluster-lifecycle).

------
#### [ CLI ]

**Para iniciar um cluster com o Spark instalado com o AWS CLI**

1. Crie perfis do IAM padrão que podem ser usados para criar seu cluster ao usar o comando apresentado a seguir.

   ```
   aws emr create-default-roles
   ```

   Para obter mais informações sobre `create-default-roles`, consulte [AWS CLI Command Reference](https://docs.aws.amazon.com/cli/latest/reference/emr/create-default-roles.html).

1. Crie um cluster do Spark com o comando a seguir. Insira um nome para o seu cluster com a opção `--name` e especifique o nome do seu par de chaves do EC2 com a opção `--ec2-attributes`.

   ```
   aws emr create-cluster \
   --name {{"<My First EMR Cluster>"}} \
   --release-label {{<emr-5.36.2>}} \
   --applications Name=Spark \
   --ec2-attributes KeyName={{<myEMRKeyPairName>}} \
   --instance-type m5.xlarge \
   --instance-count 3 \
   --use-default-roles
   ```

   Observe os outros valores necessários para `--instance-type`, `--instance-count` e `--use-default-roles`. Esses valores foram escolhidos para clusters de uso geral. Para obter mais informações sobre `create-cluster`, consulte [AWS CLI Command Reference](https://docs.aws.amazon.com/cli/latest/reference/emr/create-cluster.html).
**nota**  
Os caracteres de continuação de linha do Linux (\\) 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 (^).

   O resultado deverá ser parecido com o que segue. A saída mostra o `ClusterId` e o `ClusterArn` do seu novo cluster. Anote o seu `ClusterId`. Você usa o `ClusterId` para verificar o status do cluster e enviar trabalhos.

   ```
   {
       "ClusterId": "{{myClusterId}}",
       "ClusterArn": "{{myClusterArn}}"
   }
   ```

1. Verifique o status do seu cluster com o comando a seguir.

   ```
   aws emr describe-cluster --cluster-id {{<myClusterId>}}						
   ```

   Você deverá visualizar uma saída semelhante à apresentada a seguir com o objeto `Status` para o seu novo cluster.

   ```
   {
       "Cluster": {
           "Id": "{{myClusterId}}",
           "Name": "{{My First EMR Cluster}}",
           "Status": {
               "State": "STARTING",
               "StateChangeReason": {
                   "Message": "Configuring cluster software"
               }
           }
        }
   }
   ```

   O valor de `State` é alterado de `STARTING` para `RUNNING` e, em seguida, para `WAITING`, conforme o Amazon EMR provisiona o cluster.

O status do cluster é alterado para `WAITING` quando um cluster está ativo, em execução e pronto para aceitar trabalhos. Para obter informações sobre o status do cluster, consulte [Noções básicas sobre o ciclo de vida do cluster](emr-overview.md#emr-overview-cluster-lifecycle).

------

## Etapa 2: enviar o trabalho ao cluster do Amazon EMR
<a name="emr-getting-started-manage"></a>

### Enviar o trabalho e exibir os resultados
<a name="emr-getting-started-submit-spark-step"></a>

Após iniciar um cluster, você poderá enviar trabalhos ao cluster em execução para processar e analisar dados. Você envia os trabalhos para um cluster do Amazon EMR como uma *etapa*. Uma etapa é uma unidade de trabalho composta por uma ou mais ações. Por exemplo, você pode enviar uma etapa para calcular valores ou para transferir e processar dados. É possível enviar etapas ao criar um cluster ou para um cluster em execução. Nesta parte do tutorial, você envia `health_violations.py` como uma etapa para o cluster em execução. Para saber mais sobre as etapas, consulte [Envio de trabalhos para um cluster do Amazon EMR](emr-work-with-steps.md).

------
#### [ Console ]

**Para enviar uma aplicação do Spark como uma etapa usando o console**

1. [Faça login no e abra Console de gerenciamento da AWS o console do Amazon EMR em https://console.aws.amazon.com /emr.](https://console.aws.amazon.com/emr)

1. Em **EMR no EC2**, no painel de navegação esquerdo, escolha **Clusters** e, em seguida, selecione o cluster para o qual deseja enviar o trabalho. O estado do cluster deve ser **Aguardando**.

1. Escolha a guia **Etapas** e, em seguida, escolha **Adicionar etapa**.

1. Configure a etapa de acordo com as seguintes diretrizes:
   + Para **Tipo**, escolha **Aplicação do Spark**. Você deverá visualizar campos adicionais para **Modo de implantação**, **Local da aplicação** e **Opções de spark-submit**.
   + Para **Nome**, insira um novo nome. Se você tiver muitas etapas em um cluster, nomear cada etapa ajudará a controlá-las.
   + Para **Modo de implantação**, deixe o valor padrão **Modo de cluster**. Para obter mais informações sobre os modos de implantação do Spark, consulte [Cluster mode overview](https://spark.apache.org/docs/latest/cluster-overview.html) na documentação do Apache Spark.
   + Em **Localização do aplicativo**, insira a localização do seu `health_violations.py` script no Amazon S3, como. {{s3://amzn-s3-demo-bucket/health\_violations.py}}
   + Deixe o campo **Opções de spark-submit** vazio. Para obter mais informações sobre as opções de `spark-submit`, consulte [Launching applications with spark-submit](https://spark.apache.org/docs/latest/submitting-applications.html#launching-applications-with-spark-submit). 
   + No campo **Argumentos**, insira os seguintes argumentos e valores:

     ```
     --data_source {{s3://amzn-s3-demo-bucket/food_establishment_data.csv}}
     --output_uri {{s3://amzn-s3-demo-bucket/myOutputFolder}}
     ```

     {{s3://amzn-s3-demo-bucket/food\_establishment\_data.csv}}Substitua pelo URI do bucket do S3 dos dados de entrada que você preparou. [Preparação de uma aplicação com dados de entrada para o Amazon EMR](#emr-getting-started-prepare-app)

     {{amzn-s3-demo-bucket}}Substitua pelo nome do bucket que você criou para este tutorial e {{myOutputFolder}} substitua por um nome para a pasta de saída do cluster.
   + Para **Ação se a etapa falhar**, aceite a opção padrão **Continuar**. Dessa forma, se a etapa falhar, o cluster continuará em execução.

1. Escolha **Adicionar** para enviar a etapa. A etapa deve ser exibida no console com o status **Pendente**.

1. Monitore o status da etapa. Ele deve ser alterado de **Pendente** para **Em execução** e, por fim, para **Concluído**. Para atualizar o status no console, escolha o ícone de atualização à direita de **Filtrar**. O script demora cerca de um minuto para ser executado. Quando o status for alterado para **Concluído**, a etapa será concluída com êxito.

------
#### [ CLI ]

**Para enviar uma inscrição no Spark como uma etapa com o AWS CLI**

1. Certifique-se de ter o `ClusterId` do cluster iniciado em [Inicialização de um cluster do Amazon EMR](#emr-getting-started-launch-sample-cluster). Também é possível recuperar o ID do cluster com o comando apresentado a seguir.

   ```
   aws emr list-clusters --cluster-states WAITING							
   ```

1.  Envie `health_violations.py` como uma etapa com o comando `add-steps` e seu `ClusterId`.
   + Você pode especificar um nome para sua etapa substituindo{{"My Spark Application"}}. Na `Args` matriz, {{s3://amzn-s3-demo-bucket/health\_violations.py}} substitua pela localização do seu `health_violations.py` aplicativo.
   + {{s3://amzn-s3-demo-bucket/food\_establishment\_data.csv}}Substitua pela localização do seu `food_establishment_data.csv` conjunto de dados no S3.
   + {{s3://amzn-s3-demo-bucket/MyOutputFolder}}Substitua pelo caminho S3 do bucket designado e por um nome para a pasta de saída do cluster.
   + `ActionOnFailure=CONTINUE` significa que o cluster continuará em execução se a etapa falhar.

   ```
   aws emr add-steps \
   --cluster-id {{<myClusterId>}} \
   --steps Type=Spark,Name={{"<My Spark Application>"}},ActionOnFailure=CONTINUE,Args=[{{<s3://amzn-s3-demo-bucket/health_violations.py>}},--data_source,{{<s3://amzn-s3-demo-bucket/food_establishment_data.csv>}},--output_uri,{{<s3://amzn-s3-demo-bucket/MyOutputFolder>}}]
   ```

   Para obter mais informações sobre o envio de etapas usando a CLI, consulte [AWS CLI Command Reference](https://docs.aws.amazon.com/cli/latest/reference/emr/add-steps.html).

   Após enviar a etapa, você deverá visualizar uma saída como a apresentada a seguir, com uma lista de `StepIds`. Como você enviou uma etapa, verá somente um ID na lista. Copie o ID da etapa. Você usa o ID da etapa para verificar o status da etapa.

   ```
   {
       "StepIds": [
           "s-1XXXXXXXXXXA"
       ]
   }
   ```

1. Consulte o status da sua etapa com o comando `describe-step`.

   ```
   aws emr describe-step --cluster-id {{<myClusterId>}} --step-id {{<s-1XXXXXXXXXXA>}}							
   ```

   Você deverá visualizar uma saída como a apresentada a seguir com informações sobre a etapa.

   ```
   {
       "Step": {
           "Id": "s-1XXXXXXXXXXA",
           "Name": "My Spark Application",
           "Config": {
               "Jar": "command-runner.jar",
               "Properties": {},
               "Args": [
                   "spark-submit",
                   "s3://amzn-s3-demo-bucket/health_violations.py",
                   "--data_source",
                   "s3://amzn-s3-demo-bucket/food_establishment_data.csv",
                   "--output_uri",
                   "s3://amzn-s3-demo-bucket/myOutputFolder"
               ]
           },
           "ActionOnFailure": "CONTINUE",
           "Status": {
               "State": "COMPLETED"
           }
       }
   }
   ```

   O `State` da etapa é alterado de `PENDING` para `RUNNING` e para `COMPLETED`, conforme a etapa é executada. A etapa demora cerca de um minuto para ser executada, então pode ser necessário verificar o status algumas vezes.

Você saberá que a etapa obteve êxito quando o `State` for alterado para `COMPLETED`.

------

Para obter mais informações sobre o ciclo de vida da etapa, consulte [Execução de etapas para processar dados](emr-overview.md#emr-overview-steps).

### Visualização dos resultados
<a name="emr-getting-started-view-results"></a>

Após a execução com êxito de uma etapa, você poderá visualizar os resultados de saída na pasta de saída do Amazon S3.

**Visualizar os resultados de `health_violations.py`**

1. Abra o console do Amazon S3 em [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).

1. Escolha o **nome do bucket** e, em seguida, a pasta de saída que você especificou ao enviar a etapa. Por exemplo, {{amzn-s3-demo-bucket}} e depois{{myOutputFolder}}. 

1. Verifique se os seguintes itens aparecem na sua pasta de saída:
   + Um objeto de tamanho pequeno chamado `_SUCCESS`.
   + Um arquivo CSV que começa com o prefixo `part-`, que contém seus resultados.

1. Escolha o objeto com seus resultados e, em seguida, escolha **Fazer download** para salvar os resultados em seu sistema de arquivos local.

1. Abra os resultados no editor de sua preferência. O arquivo de saída lista os dez principais estabelecimentos de alimentação com o maior número de violações vermelhas. O arquivo de saída também mostra o número total de violações vermelhas para cada estabelecimento.

   Confira a seguir um exemplo de resultados para `health_violations.py`.

   ```
   name, total_red_violations
   SUBWAY, 322
   T-MOBILE PARK, 315
   WHOLE FOODS MARKET, 299
   PCC COMMUNITY MARKETS, 251
   TACO TIME, 240
   MCDONALD'S, 177
   THAI GINGER, 153
   SAFEWAY INC #1508, 143
   TAQUERIA EL RINCONSITO, 134
   HIMITSU TERIYAKI, 128
   ```

Para obter mais informações sobre a saída do cluster do Amazon EMR, consulte [Configurar um local para a saída do cluster do Amazon EMR](emr-plan-output.md).

### (Opcional) Conexão com o cluster do Amazon EMR em execução
<a name="emr-getting-started-connect-to-cluster"></a>

Ao usar o Amazon EMR, você pode desejar se conectar a um cluster em execução para ler arquivos de log, depurar o cluster ou usar ferramentas da CLI, como o shell do Spark. O Amazon EMR permite que você se conecte a um cluster usando o protocolo Secure Shell (SSH). Esta seção abrange como configurar o SSH, conectar-se ao cluster e visualizar arquivos de log do Spark. Para obter mais informações sobre como se conectar a um cluster, consulte [Autenticação em nós de cluster do Amazon EMR](emr-authenticate-cluster-connections.md).

#### Autorização de conexões SSH para o cluster
<a name="emr-getting-started-restrict-ssh"></a>

Antes de se conectar ao cluster, é necessário modificar os grupos de segurança do cluster para autorizar conexões SSH de entrada. Os grupos de segurança do Amazon EC2 atuam como firewalls virtuais para controlar o tráfego de entrada e de saída do cluster. Quando você criou o cluster para este tutorial, o Amazon EMR criou os seguintes grupos de segurança em seu nome:

**ElasticMapReduce-mestre**  
O grupo de segurança gerenciado padrão do Amazon EMR associado ao nó primário. Em um cluster do Amazon EMR, o nó primário corresponde a uma instância do Amazon EC2 que gerencia o cluster.

**ElasticMapReduce-escravo**  
O grupo de segurança padrão associado aos nós centrais e de tarefa.

------
#### [ Console ]

**Para permitir o acesso SSH a fontes confiáveis ​​ao grupo de segurança primário com o console**

Para editar seus grupos de segurança, você deve ter permissão para gerenciar os grupos de segurança para a VPC na qual o cluster está localizado. Para obter mais informações, consulte [Alteração de permissões de um usuário](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_users_change-permissions.html) e o [exemplo de política](https://docs.aws.amazon.com//IAM/latest/UserGuide/reference_policies_examples_ec2_securitygroups-vpc.html) que permite o gerenciamento de grupos de segurança do EC2 no *Guia do usuário do IAM*.

1. [Faça login no e abra Console de gerenciamento da AWS o console do Amazon EMR em https://console.aws.amazon.com /emr.](https://console.aws.amazon.com/emr)

1. Em **EMR no EC2** no painel de navegação esquerdo, escolha **Clusters** e, em seguida, escolha o cluster que você deseja atualizar. Isso abre a página de detalhes do cluster. A guia **Propriedades** nesta página deve estar pré-selecionada.

1. Em **Redes** na guia **Propriedades**, selecione a seta ao lado de **Grupos de segurança do EC2 (firewall)** para expandir esta seção. Em **Nó primário**, selecione o link do grupo de segurança. Ao concluir as etapas apresentadas a seguir, como opção, você poderá voltar a esta etapa, escolher **Nós centrais e de tarefa** e repetir as etapas a seguir para permitir o acesso do cliente SSH aos nós centrais e de tarefas.

1. Isso abre o console do EC2. Escolha a guia **Regras de entrada** e, em seguida, **Editar regras de entrada**.

1. Verifique se há uma regra de entrada que permita acesso público com as configurações a seguir. Se existir, escolha **Excluir** para removê-la.
   + **Tipo**

     SSH
   + **Porta**

     22
   + **Origem**

     Personalizado 0.0.0.0/0
**Atenção**  
Antes de dezembro de 2020, o grupo de segurança ElasticMapReduce -master tinha uma regra pré-configurada para permitir tráfego de entrada na Porta 22 de todas as fontes. Essa regra foi criada para simplificar as conexões SSH iniciais com o nó principal. Recomendamos fortemente remover esta regra de entrada e restringir o tráfego para origens confiáveis.

1. Role até o final da lista de regras e escolha **Adicionar regra**.

1. Em **Type (Tipo)**, selecione **SSH**. Selecionar SSH insere automaticamente **TCP** para **Protocolo** e **22** para **Intervalo de portas**.

1. Para a origem, selecione **Meu IP** para adicionar automaticamente seu endereço IP como o endereço de origem. Você também pode adicionar um intervalo ​​**personalizado** de endereços IP de clientes confiáveis ou criar regras adicionais para outros clientes. Diversos ambientes de rede alocam endereços IP dinamicamente, portanto, pode ser necessário atualizar os endereços IP para clientes confiáveis ​​no futuro.

1. Escolha **Salvar**.

1. Como opção, escolha **Nós centrais e de tarefa** na lista e repita as etapas acima para permitir o acesso do cliente SSH aos nós centrais e de tarefa.

------

#### Conecte-se ao seu cluster usando o AWS CLI
<a name="emr-getting-started-connect-ssh"></a>

Independentemente do seu sistema operacional, é possível criar uma conexão SSH com o cluster usando a AWS CLI.

**Para se conectar ao seu cluster e visualizar os arquivos de log usando o AWS CLI**

1. Use o comando a seguir para abrir uma conexão SSH com o cluster. {{<mykeypair.key>}}Substitua pelo caminho completo e pelo nome do arquivo do seu arquivo de key pair. Por exemplo, .`C:\Users\<username>\.ssh\mykeypair.pem`

   ```
   aws emr ssh --cluster-id {{<j-2AL4XXXXXX5T9>}} --key-pair-file {{<~/mykeypair.key>}}						
   ```

1. Navegue até `/mnt/var/log/spark` para acessar os logs do Spark no nó principal do cluster. Em seguida, visualize os arquivos nesse local. Para obter uma lista de arquivos de log adicionais no nó principal, consulte [Visualizar arquivos de log no nó primário](emr-manage-view-web-log-files.md#emr-manage-view-web-log-files-master-node).

   ```
   cd /mnt/var/log/spark
   ls
   ```

### Use o Amazon SageMaker AI Unified Studio para gerenciar seu cluster do Amazon EMR
<a name="emr-getting-started-connect-to-cluster-sagemaker"></a>

 O Amazon EMR no EC2 também é um tipo de computação compatível com o Unified Studio. Amazon SageMaker AI Consulte [Gerenciando o Amazon EMR no EC2](https://docs.aws.amazon.com/sagemaker-unified-studio/latest/userguide/managing-emr-on-ec2.html) para saber como usar e gerenciar o EMR nos recursos do EC2 no Unified Studio. Amazon SageMaker AI 

## Etapa 3: limpar os recursos do Amazon EMR
<a name="emr-getting-started-clean-up"></a>

### Encerramento do cluster
<a name="emr-getting-started-stop-cluster"></a>

Agora que você enviou o trabalho para seu cluster e visualizou os resultados do seu PySpark aplicativo, você pode encerrar o cluster. O encerramento de um cluster interrompe todas as cobranças do Amazon EMR e das instâncias do Amazon EC2 associadas ao cluster.

Ao encerrar um cluster, o Amazon EMR retém os metadados relacionados ao cluster por dois meses gratuitamente. Os metadados arquivados ajudam a [clonar o cluster](clone-console.md) para um novo trabalho ou a revisitar a configuração do cluster para finalidades de referência. Os metadados *não* incluem os dados que o cluster grava no S3 ou os dados armazenados no HDFS no cluster. 

**nota**  
O console do Amazon EMR não permite que você exclua um cluster da visualização de lista após o encerramento do cluster. Um cluster encerrado desaparecerá do console quando o Amazon EMR limpar os metadados. 

------
#### [ Console ]

**Para encerrar o cluster com o console**

1. [Faça login no e abra Console de gerenciamento da AWS o console do Amazon EMR em https://console.aws.amazon.com /emr.](https://console.aws.amazon.com/emr)

1. Escolha **Clusters** e, em seguida, selecione o cluster que você deseja encerrar.

1. No menu suspenso **Ações**, escolha **Encerrar cluster**.

1. Escolha **Encerrar** na caixa de diálogo. Dependendo da configuração do cluster, o encerramento pode demorar de cinco a dez minutos. Para obter mais informações sobre os clusters do Amazon EMR, consulte [Encerramento de um cluster do Amazon EMR em estado iniciando, executando ou aguardando](UsingEMR_TerminateJobFlow.md).

------
#### [ CLI ]

**Para encerrar o cluster com o AWS CLI**

1. Inicie o processo de encerramento do cluster com o comando a seguir. {{<myClusterId>}}Substitua pelo ID do seu cluster de amostra. O comando não retorna uma saída.

   ```
   aws emr terminate-clusters --cluster-ids {{<myClusterId>}}
   ```

1. Para verificar se o processo de encerramento do cluster está em andamento, verifique o status do cluster com o comando a seguir.

   ```
   aws emr describe-cluster --cluster-id {{<myClusterId>}}									
   ```

   A seguir é apresentado uma saída de exemplo no formato JSON. O `Status` do cluster deve ser alterado de **`TERMINATING`** para **`TERMINATED`**. O encerramento pode demorar de cinco a dez minutos, dependendo da configuração do cluster. Para obter mais informações sobre como encerrar um cluster do Amazon EMR, consulte [Encerramento de um cluster do Amazon EMR em estado iniciando, executando ou aguardando](UsingEMR_TerminateJobFlow.md).

   ```
   {
       "Cluster": {
           "Id": "j-xxxxxxxxxxxxx",
           "Name": "My Cluster Name",
           "Status": {
               "State": "TERMINATED",
               "StateChangeReason": {
                   "Code": "USER_REQUEST",
                   "Message": "Terminated by user request"
               }
           }
       }
   }
   ```

------

### Exclusão de recursos do S3
<a name="emr-getting-started-delete-bucket"></a>

Para evitar cobranças adicionais, você deve excluir o bucket do Amazon S3. Excluir o bucket remove todos os recursos do Amazon S3 deste tutorial. O bucket deve conter:
+ O PySpark roteiro
+ O conjunto de dados de entrada.
+ Sua pasta de resultados de saída.
+ Sua pasta de arquivos de log.

Talvez seja necessário tomar medidas adicionais para excluir os arquivos armazenados se você salvou o PySpark script ou a saída em um local diferente.

**nota**  
O cluster deve ser encerrado antes de você excluir o bucket. Caso contrário, pode não ser possível esvaziar o bucket.

Para excluir seu bucket, siga as instruções apresentadas em [How do I delete an S3 bucket?](https://docs.aws.amazon.com/AmazonS3/latest/userguide/delete-bucket.html) no *Guia do usuário do Amazon Simple Storage Service*.

## Próximas etapas
<a name="emr-gs-next-steps"></a>

Você iniciou seu primeiro cluster do Amazon EMR do início ao fim. Você também concluiu tarefas essenciais do EMR, como preparar e enviar aplicações de big data, visualizar os resultados e encerrar um cluster. 

Use os tópicos apresentados a seguir para saber mais sobre como personalizar seu fluxo de trabalho do Amazon EMR.

### Exploração de aplicações de big data para o Amazon EMR
<a name="emr-gs-next-explore-apps"></a>

Descubra e compare as aplicações de big data que podem ser instaladas em um cluster no [Guia de versão do Amazon EMR](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-release-components.html). O guia de lançamento detalha cada versão lançada do EMR e inclui dicas para usar estruturas como o Spark e o Hadoop no Amazon EMR.

### Planejamento do hardware, das redes e da segurança do cluster
<a name="emr-gs-next-plan-clusters"></a>

Neste tutorial, você criou um cluster do EMR simples, sem configurar as opções avançadas. As opções avançadas permitem especificar os tipos de instância do Amazon EC2, as redes do cluster e a segurança do cluster. Para obter mais informações sobre como planejar e iniciar um cluster que atenda aos seus requisitos, consulte [Planejamento, configuração e inicialização de clusters do Amazon EMR](emr-plan.md) e [Segurança no Amazon EMR](emr-security.md).

### Gerenciar clusters
<a name="emr-gs-next-manage-clusters"></a>

Aprofunde-se no trabalho com clusters em execução em [Gerenciamento de clusters do Amazon EMR](emr-manage.md). Para gerenciar um cluster, é possível se conectar ao cluster, depurar etapas e rastrear as atividades e a integridade do cluster. Você também pode ajustar os recursos do cluster em resposta às demandas da workload com o [ajuste de escala gerenciado do EMR](emr-managed-scaling.md).

### Uso de uma interface diferente
<a name="emr-gs-next-interfaces"></a>

Além do console do Amazon EMR, você pode gerenciar o Amazon EMR usando a API do AWS Command Line Interface serviço web ou uma das muitas suportadas. AWS SDKs Para obter mais informações, consulte [Interfaces de gerenciamento](emr-overview-benefits.md#emr-what-tools).

Você também pode interagir com aplicações instaladas em clusters do Amazon EMR de diversas maneiras. Algumas aplicações, como o Apache Hadoop, publicam interfaces da Web que você pode visualizar. Para obter mais informações, consulte [Visualizar interfaces Web hospedadas em clusters do Amazon EMR](emr-web-interfaces.md).

### Navegação pelo blog técnico do EMR
<a name="emr-gs-next-browse-blogs"></a>

Para obter exemplos de orientações e discussões técnicas aprofundadas sobre os novos recursos do Amazon EMR, consulte o [blog de big data da AWS](https://aws.amazon.com/blogs/big-data/tag/amazon-emr/).