# Endpoints de desenvolvimento
**nota**
**A experiência do console para endpoints de desenvolvimento foi removida em 31 de março de 2023.** A criação, a atualização e o monitoramento de endpoints de desenvolvimento ainda estão disponíveis por meio do [API de endpoints de desenvolvimento](aws-glue-api-dev-endpoint.md) e da [CLI do AWS Glue](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/glue/index.html#cli-aws-glue).
É altamente recomendável migrar de endpoints de desenvolvimento para sessões interativas pelos motivos listados abaixo. Para ver as ações necessárias para migrar endpoints de desenvolvimento para sessões interativas, consulte [Migrar de endpoints de desenvolvimento para sessões interativas](https://docs.aws.amazon.com/glue/latest/dg/development-migration-checklist.html).
| Descrição | Endpoints de desenvolvimento | Sessões interativas |
| --- | --- | --- |
| Compatibilidade com versão do Glue | Compatível com o AWS Glue versões 0.9 e 1.0 | Compatível com o AWS Glue versões 2.0 e posteriores |
| A partir de agora, os endpoints de desenvolvimento não estarão disponíveis nas regiões Ásia-Pacífico (Jacarta) (ap-southeast-3), Oriente Médio (EAU) (me-central-1) Europa (Espanha) (eu-south-2), Europa (Zurique) (eu-central-2) nem outras regiões novas | No momento, sessões interativas não estão disponíveis na região Oriente Médio (EAU) (me-central-1), mas podem ser disponibilizadas posteriormente |
| Método de acesso ao cluster do Spark | Compatível com SSH, shell do REPL, caderno Jupyter, IDE (por exemplo, PyCharm) | Compatível com caderno do AWS Glue Studio, o caderno Jupyter, vários IDEs (por exemplo, Visual Studio Code, PyCharm) e caderno do SageMaker AI |
| Tempo até o primeiro byte | Requer de 10 a 15 minutos para configurar um cluster do Spark | Pode levar até 1 minuto para configurar um cluster efêmero do Spark |
| O modelo de preços | A AWS cobra pelos endpoints de desenvolvimento com base no tempo que o endpoint é provisionado e no número de DPUs. Os endpoints de desenvolvimento não têm tempo limite. Há uma duração mínima para cobrança de 10 minutos para cada endpoint de desenvolvimento provisionado. Além disso, a AWS cobra pelas instâncias do caderno Jupyter no Amazon EC2 e pelos caderno do SageMaker AI quando você os configura com o endpoint de desenvolvimento. | A AWS cobra por sessões interativas com base no tempo que a sessão permanece ativa e no número de DPUs. As sessões interativas têm tempos limites de inatividade configuráveis. Os cadernos do AWS Glue Studio oferecem uma interface integrada para sessões interativas e são oferecidos sem custo adicional. Há uma duração mínima para cobrança de 1 minuto para cada sessão interativa. Os cadernos do AWS Glue Studio fornecem uma interface embutida para sessões interativas e são oferecidos sem custo adicional |
| Experiência de console | Disponível somente por meio da CLI e da API | Disponível por meio do console, da CLI e de APIs do AWS Glue |
# Migrar de endpoints de desenvolvimento para sessões interativas
Use a lista de verificação a seguir para determinar o método apropriado para migrar de endpoints de desenvolvimento para sessões interativas.
**Seu script depende de recursos específicos do AWS Glue 0.9 ou 1.0 (por exemplo, HDFS, YARN etc.)? **
Se a resposta for sim, consulte [Migrar trabalhos do AWS Glue para o AWS Glue versão 3.0](https://docs.aws.amazon.com/glue/latest/dg/migrating-version-30.html) para saber como migrar do Glue 0.9 ou 1.0 para o Glue 3.0 e versões posteriores.
**Qual método você usa para acessar o endpoint de desenvolvimento?**
| Se você usar este método | Então faça isso |
| --- | --- |
| Caderno do SageMaker AI, caderno Jupyter ou JupyterLab | Migre para o [caderno AWS Glue Studio](https://docs.aws.amazon.com/glue/latest/dg/interactive-sessions-gs-notebook.html) baixando os arquivos .ipynb no Jupyter e crie um novo trabalho de caderno AWS Glue Studio carregando o arquivo .ipynb. Ou então, você pode usar o [SageMaker AI Studio](https://aws.amazon.com/blogs/machine-learning/prepare-data-at-scale-in-amazon-sagemaker-studio-using-serverless-aws-glue-interactive-sessions/) e selecionar o kernel do AWS Glue. |
| Notebook do Zeppelin | Converta o caderno em um caderno Jupyter manualmente, copiando e colando o código, ou automaticamente, usando um conversor de terceiros, como o ze2nb. Em seguida, use o caderno no caderno do AWS Glue Studio ou do SageMaker AI Studio. |
| IDE | Consulte [Criar trabalhos do AWS Glue com o PyCharm usando as sessões interativas do AWS Glue](https://aws.amazon.com/blogs/big-data/author-aws-glue-jobs-with-pycharm-using-aws-glue-interactive-sessions/) ou [Usar sessões interativas com o código do Microsoft Visual Studio](https://docs.aws.amazon.com/glue/latest/dg/interactive-sessions-vscode.html). |
| RESPOSTA | Instale o [https://docs.aws.amazon.com/glue/latest/dg/interactive-sessions.html](https://docs.aws.amazon.com/glue/latest/dg/interactive-sessions.html) localmente e depois execute o seguinte comando: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/development-migration-checklist.html) |
| SSH | Não há nenhuma opção correspondente nas sessões interativas. Como alternativa, você pode usar uma imagem do Docker. Para saber mais, consulte [Desenvolver usando com uma imagem do Docker](https://docs.aws.amazon.com/glue/latest/dg/aws-glue-programming-etl-libraries.html#develop-local-docker-image). |
As seções a seguir fornecem mais informações sobre o uso de endpoints de desenvolvimento para desenvolver trabalhos no AWS Glue versão 1.0.
**Topics**
+ [Migrar de endpoints de desenvolvimento para sessões interativas](development-migration-checklist.md)
+ [Desenvolver scripts com endpoints de desenvolvimento](dev-endpoint.md)
+ [Gerenciar cadernos](notebooks-with-glue.md)
# Desenvolver scripts com endpoints de desenvolvimento
**nota**
Os endpoints de desenvolvimento só são compatíveis com as versões do AWS Glue anteriores à 2.0. Para um ambiente interativo onde você possa criar e testar scripts de ETL, use [Notebooks on AWS Glue Studio](https://docs.aws.amazon.com/glue/latest/ug/notebooks-chapter.html).
O AWS Glue pode criar um ambiente, conhecido como *endpoint de desenvolvimento*, que você pode usar para desenvolver e testar iterativamente seus scripts de extração, transformação e carregamento (ETL). Você pode criar, editar e excluir endpoints de desenvolvimento usando o console ou a API do AWS Glue.
## Gerenciar o ambiente de desenvolvimento
Ao criar um endpoint de desenvolvimento, você fornece valores de configuração para provisionar o ambiente de desenvolvimento. Esses valores informam ao AWS Glue como configurar a rede para que você possa acessar o endpoint de forma segura e o endpoint possa acessar seus armazenamentos de dados.
Depois, é possível criar um notebook que se conecte ao endpoint e usá-lo para criar e testar seu script de ETL. Quando estiver satisfeito com os resultados do seu processo de desenvolvimento, você poderá criar um trabalho de ETL que execute seu script. Com esse processo, você pode adicionar funções e depurar seus scripts de forma interativa.
Siga os tutoriais nesta seção para saber como usar seu endpoint de desenvolvimento com notebooks.
**Topics**
+ [Gerenciar o ambiente de desenvolvimento](#dev-endpoint-managing-dev-environment)
+ [Fluxo de trabalho do endpoint de desenvolvimento](dev-endpoint-workflow.md)
+ [Como os endpoints de desenvolvimento do AWS Glue funcionam com cadernos do SageMaker](dev-endpoint-how-it-works.md)
+ [Adicionar um endpoint de desenvolvimento](add-dev-endpoint.md)
+ [Acessar o endpoint de desenvolvimento](dev-endpoint-elastic-ip.md)
+ [Tutorial: configurar um caderno Jupyter no JupyterLab para testar e depurar scripts de ETL](dev-endpoint-tutorial-local-jupyter.md)
+ [Tutorial: usar um caderno do SageMaker AI com seu endpoint de desenvolvimento](dev-endpoint-tutorial-sage.md)
+ [Tutorial: usar um shell REPL com seu endpoint de desenvolvimento](dev-endpoint-tutorial-repl.md)
+ [Tutorial: configurar um PyCharm Professional com um endpoint de desenvolvimento](dev-endpoint-tutorial-pycharm.md)
+ [Configuração avançada: compartilhar endpoints de desenvolvimento entre vários usuários](dev-endpoint-sharing.md)
# Fluxo de trabalho do endpoint de desenvolvimento
Para usar um endpoint de desenvolvimento do AWS Glue, você pode seguir este fluxo de trabalho:
1. Crie um endpoint de desenvolvimento usando o console ou a API. O endpoint é executado em uma nuvem privada virtual (VPC) com seus grupos de segurança definidos.
1. O console ou a API sonda o endpoint de desenvolvimento até que ele seja provisionado e esteja pronto para operar. Quando estiver pronto, conecte-se ao endpoint de desenvolvimento usando um dos seguintes métodos para criar e testar scripts do AWS Glue.
+ Crie um caderno do SageMaker AI em sua conta. Para obter mais informações sobre como criar um notebook, consulte [Criação de código com notebooks AWS Glue Studio](notebooks-chapter.md).
+ Abra uma janela de terminal para se conectar diretamente a um endpoint de desenvolvimento.
+ Se tiver a versão profissional do [PyCharm Python IDE](https://www.jetbrains.com/pycharm/) do JetBrains, conecte-a a um endpoint de desenvolvimento e use-a para desenvolver de forma interativa. Se você inserir as instruções `pydevd` no seu script, o PyCharm poderá oferecer suporte a pontos de interrupção remotos.
1. Ao concluir a depuração e o teste no seu endpoint de desenvolvimento, você poderá excluí-lo.
# Como os endpoints de desenvolvimento do AWS Glue funcionam com cadernos do SageMaker
Uma das maneiras comuns de acessar seus endpoints de desenvolvimento é usar o [Jupyter](https://jupyter.org/) em cadernos do SageMaker. O caderno Jupyter é um aplicação Web de código aberto que é amplamente utilizada em visualização, analytics, machine learning etc. Um caderno do SageMaker do AWS Glue oferece uma experiência de caderno Jupyter com endpoints de desenvolvimento do AWS Glue. No caderno do SageMaker do AWS Glue, o ambiente de caderno Jupyter é pré-configurado com [SparkMagic](https://github.com/jupyter-incubator/sparkmagic), um plugin de código aberto do Jupyter para enviar trabalhos do Spark para um cluster remoto do Spark. [Apache Livy](https://livy.apache.org) é um serviço que permite a interação com um cluster remoto do Spark por meio de uma API REST. No caderno do SageMaker do AWS Glue, o SparkMagic está configurado para chamar a API REST em um servidor Livy em execução em um endpoint de desenvolvimento do AWS Glue.
O fluxo de texto a seguir explica como cada componente funciona:
*Notebook do SageMaker do AWS Glue: (Jupyter → SparkMagic) → (rede) → endpoint de desenvolvimento do AWS Glue: (Apache Livy → Apache Spark)*
Depois de executar o script do Spark escrito em cada parágrafo em um caderno Jupyter, o código do Spark é enviado ao servidor Livy via SparkMagic e, em seguida, um trabalho do Spark chamado “livy-session-N” é executado no cluster do Spark. Esse trabalho é chamado de sessão do Livy. O trabalho do Spark será executado enquanto a sessão do caderno estiver ativa. O trabalho do Spark será terminado quando você desligar o kernel do Jupyter do caderno, ou quando o tempo da sessão se esgotar. Um trabalho do Spark é iniciado por arquivo de caderno (.ipynb).
Você pode usar um único endpoint de desenvolvimento do AWS Glue com várias instâncias de cadernos do SageMaker. Você pode criar vários arquivos de caderno em cada instância de cadernos do SageMaker. Quando você abre um arquivo de cada caderno e executa os parágrafos, uma sessão do Livy é iniciada por arquivo de caderno no cluster do Spark via SparkMagic. Cada sessão do Livy corresponde a um único trabalho do Spark.
## Comportamento padrão para endpoints de desenvolvimento do AWS Glue e cadernos do SageMaker
Os trabalhos do Spark são executados com base na [configuração do Spark](https://spark.apache.org/docs/2.4.3/configuration.html). Existem várias maneiras de definir a configuração do Spark (por exemplo, configuração do cluster do Spark, configuração do SparkMagic etc.).
Por padrão, o Spark aloca recursos de cluster para uma sessão do Livy com base na configuração do cluster do Spark. Em endpoints de desenvolvimento do AWS Glue, a configuração do cluster depende do tipo de operador. Esta tabela explica as configurações comuns por tipo de operador.
****
| | Standard | G.1X | G.2X |
| --- | --- | --- | --- |
| spark.driver.memory | 5G | 10G | 20G |
| spark.executor.memory | 5G | 10G | 20G |
| spark.executor.cores | 4 | 8 | 16 |
| spark.dynamicAllocation.enabled | TRUE | TRUE | TRUE |
O número máximo de executores do Spark é calculado automaticamente pela combinação de DPU (ou `NumberOfWorkers`) e tipo de operador.
****
| | Standard | G.1X | G.2X |
| --- | --- | --- | --- |
| O número máximo de executores do Spark | (DPU - 1) \$1 2 - 1 | (NumberOfWorkers - 1) | (NumberOfWorkers - 1) |
Por exemplo, se o endpoint de desenvolvimento tiver dez operadores e o tipo de operador for ` G.1X`, então você terá nove executores do Spark e todo o cluster terá 90G de memória de executor, uma vez que cada executor terá 10G de memória.
Independentemente do tipo de operador especificado, a alocação dinâmica de recursos do Spark será ativada. Se um conjunto de dados for grande o suficiente, o Spark pode alocar todos os executores em uma única sessão do Livy, já que `spark.dynamicAllocation.maxExecutors` não é definido por padrão. Isso significa que outras sessões do Livy no mesmo endpoint de desenvolvimento esperarão para iniciar novos executores. Se o conjunto de dados for pequeno, o Spark poderá alocar executores em várias sessões do Livy ao mesmo tempo.
**nota**
Para obter mais informações sobre como os recursos são alocados em diferentes casos de uso e como você define uma configuração para modificar o comportamento, consulte [Configuração avançada: compartilhar endpoints de desenvolvimento entre vários usuários](dev-endpoint-sharing.md).
# Adicionar um endpoint de desenvolvimento
Use endpoints de desenvolvimento para desenvolver e testar iterativamente seus scripts de extração, transformação e carregamento (ETL) no AWS Glue. Só é possível trabalhar com endpoints de desenvolvimento por meio do AWS Command Line Interface.
1. Em uma janela de linha de comando, insira um comando semelhante ao seguinte.
```
aws glue create-dev-endpoint --endpoint-name "endpoint1" --role-arn "arn:aws:iam::account-id:role/role-name" --number-of-nodes "3" --glue-version "1.0" --arguments '{"GLUE_PYTHON_VERSION": "3"}' --region "region-name"
```
Esse comando especifica o AWS Glue versão 1.0. Como essa versão oferece suporte ao Python 2 e ao Python 3, você pode usar o parâmetro `arguments` para indicar a versão desejada do Python. Se o parâmetro `glue-version` for omitido, o AWS Glue versão 0.9 será assumido. Para obter mais informações sobre as versões do AWS Glue, consulte o [Glue version job property](add-job.md#glue-version-table).
Para obter informações sobre parâmetros de linha de comando adicionais, consulte [create-dev-endpoint](https://docs.aws.amazon.com/cli/latest/reference/glue/create-dev-endpoint.html) na *Referência de comandos da AWS CLI*.
1. (Opcional) Insira o comando a seguir para verificar o status do endpoint de desenvolvimento. Quando o status mudar para `READY`, o endpoint de desenvolvimento estará pronto para uso.
```
aws glue get-dev-endpoint --endpoint-name "endpoint1"
```
# Acessar o endpoint de desenvolvimento
Quando você cria um endpoint de desenvolvimento em uma nuvem privada virtual (VPC), o AWS Glue retorna apenas um endereço IP privado. O campo de endereço IP público não é preenchido. Quando você cria um endpoint de desenvolvimento não seja da VPC, o AWS Glue retorna somente um endereço IP público.
Se o endpoint de desenvolvimento tiver um **Public address (Endereço público)**, confirme se ele está acessível com a chave privada SSH do endpoint de desenvolvimento, como no exemplo a seguir.
```
ssh -i dev-endpoint-private-key.pem glue@public-address
```
Suponha que o endpoint de desenvolvimento tenha um **Private address (Endereço privado)**, a sub-rede da VPC seja roteável pela Internet pública e seus grupos de segurança permitam acesso de entrada do cliente. Nesse caso, siga estas etapas para anexar um *Elastic IP address (Endereço IP elástico)* a um endpoint de desenvolvimento para permitir o acesso na Internet.
**nota**
Se você deseja usar endereços IP elásticos, a sub-rede que está sendo usada requer um gateway de Internet associado por meio da tabela de rotas.
**Como acessar um endpoint de desenvolvimento anexando um endereço IP elástico**
1. Abra o console do AWS Glue em [https://console.aws.amazon.com/glue/](https://console.aws.amazon.com/glue/).
1. No painel de navegação, escolha **Dev endpoints (Endpoints de desenvolvimento)** e navegue até a página de detalhes do endpoint de desenvolvimento. Registre o **Private address** (Endereço privado) a ser usado na próxima etapa.
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No painel de navegação, em **Network & Security** (Rede e segurança), selecione **Network Interfaces** (Interfaces de rede).
1. Pesquise o **Private DNS (IPv4) (DNS privado (IPv4))** que corresponde ao **Private address (Endereço privado)** na página de detalhes do endpoint de desenvolvimento do console do AWS Glue.
Pode ser necessário alterar as colunas que são exibidas no console do Amazon EC2. Anote o **Network interface ID (ID da interface de rede)** (ENI) desse endereço (por exemplo, `eni-12345678`).
1. No console do Amazon EC2, em **Network & Security** (Rede e segurança), escolha **Elastic IPs** (IPs elásticos).
1. Escolha **Allocate new address (Alocar novo endereço)** e, depois, escolha **Allocate (Alocar)** para alocar um novo endereço IP elástico.
1. Na página **Elastic IPs** (IPs elásticos), selecione o **Elastic IP** (IP elástico) recém-alocado. Em seguida, selecione **Actions** (Ações) e **Associate address** (Associar endereço).
1. Na página **Associate address (Associar endereço)**, faça o seguinte:
+ Em **Resource type** (Tipo de recurso), selecione **Network interface** (Interface de rede).
+ No campo **Network interface (Interface de rede)**, digite o **Network interface ID (ID da interface de rede)** (ENI) do endereço privado.
+ Selecione **Associar **.
1. Confirme se o endereço IP elástico recém-associado está acessível com a chave privada SSH associada ao endpoint de desenvolvimento, como no exemplo a seguir.
```
ssh -i dev-endpoint-private-key.pem glue@elastic-ip
```
Para obter informações sobre como usar um bastion host para obter acesso SSH ao endereço privado do endpoint de desenvolvimento, consulte o post do blog de segurança da AWS [Securely Connect to Linux Instances Running in a Private Amazon VPC](https://aws.amazon.com/blogs/security/securely-connect-to-linux-instances-running-in-a-private-amazon-vpc/).
# Tutorial: configurar um caderno Jupyter no JupyterLab para testar e depurar scripts de ETL
Neste tutorial, você conectará um caderno Jupyter no JupyterLab em execução em sua máquina local a um endpoint de desenvolvimento. Você o faz para que possa executar, depurar e testar interativamente scripts de extração, transformação e carregamento (ETL) do AWS Glue antes de implantá-los. Este tutorial usa o redirecionamento de portas Secure Shell (SSH) para conectar sua máquina local a um endpoint de desenvolvimento do AWS Glue. Para obter mais informações, consulte [Redirecionamento de portas](https://en.wikipedia.org/wiki/Port_forwarding) na Wikipédia.
## Etapa 1: Instalar o JupyterLab e o Sparkmagic
Você pode instalar o JupyterLab usando o `conda` ou `pip`. O `conda` é um sistema de gerenciamento de pacotes e de ambientes de código aberto que é executado no Windows, macOS e Linux. Já o `pip` é o instalador de pacotes para Python.
Se estiver instalando no macOS, é necessário ter o Xcode instalado antes de instalar o Sparkmagic.
1. Instale o JupyterLab, o Sparkmagic e as extensões relacionadas.
```
$ conda install -c conda-forge jupyterlab
$ pip install sparkmagic
$ jupyter nbextension enable --py --sys-prefix widgetsnbextension
$ jupyter labextension install @jupyter-widgets/jupyterlab-manager
```
1. Verifique o diretório `sparkmagic` de `Location`.
```
$ pip show sparkmagic | grep Location
Location: /Users/username/.pyenv/versions/anaconda3-5.3.1/lib/python3.7/site-packages
```
1. Altere seu diretório para o mesmo retornado para `Location` e instale os kernels para Scala e PySpark.
```
$ cd /Users/username/.pyenv/versions/anaconda3-5.3.1/lib/python3.7/site-packages
$ jupyter-kernelspec install sparkmagic/kernels/sparkkernel
$ jupyter-kernelspec install sparkmagic/kernels/pysparkkernel
```
1. Faça download de um arquivo de amostra `config`.
```
$ curl -o ~/.sparkmagic/config.json https://raw.githubusercontent.com/jupyter-incubator/sparkmagic/master/sparkmagic/example_config.json
```
Neste arquivo de configuração, você pode configurar parâmetros relacionados ao Spark, como `driverMemory` e `executorCores`.
## Etapa 2: Iniciar o JupyterLab
Quando você inicia o JupyterLab, seu navegador da Web padrão é aberto automaticamente e o URL `http://localhost:8888/lab/workspaces/{workspace_name}` é exibido.
```
$ jupyter lab
```
## Etapa 3: iniciar o redirecionamento de porta SSH para se conectar ao endpoint de desenvolvimento
Em seguida, use o encaminhamento de porta local SSH para encaminhar uma porta local (aqui, `8998`) ao destino remoto definido por AWS Glue (`169.254.76.1:8998`).
1. Abra uma janela do terminal separada que conceda acesso ao SSH. No Microsoft Windows, você pode usar o shell BASH fornecido pelo [Git for Windows](https://git-scm.com/downloads) (Git para Windows) ou instalar o [Cygwin](https://www.cygwin.com/).
1. Execute o seguinte comando SSH, modificado da seguinte forma:
+ Substitua `private-key-file-path` pelo caminho do arquivo `.pem` que contém a chave privada correspondente à chave pública que você usou para criar seu endpoint de desenvolvimento.
+ Se você estiver redirecionando uma porta diferente de `8998`, substitua `8998` pelo número da porta que está de fato usando localmente. O endereço `169.254.76.1:8998` é a porta remota e não é alterada por você.
+ Substitua `dev-endpoint-public-dns` pelo endereço DNS público do seu endpoint de desenvolvimento. Para encontrar esse endereço, navegue até seu endpoint de desenvolvimento no console do AWS Glue, escolha o nome e copie o valor de **Public address** (Endereço público) listado na página **Endpoint details** (Detalhes do endpoint).
```
ssh -i private-key-file-path -NTL 8998:169.254.76.1:8998 glue@dev-endpoint-public-dns
```
Você provavelmente verá uma mensagem de aviso semelhante à seguinte:
```
The authenticity of host 'ec2-xx-xxx-xxx-xx.us-west-2.compute.amazonaws.com (xx.xxx.xxx.xx)'
can't be established. ECDSA key fingerprint is SHA256:4e97875Brt+1wKzRko+JflSnp21X7aTP3BcFnHYLEts.
Are you sure you want to continue connecting (yes/no)?
```
Digite **yes** (sim) e deixe aberta a janela do terminal enquanto utiliza o JupyterLab.
1. Verifique se o redirecionamento de porta SSH está funcionando corretamente com o endpoint de desenvolvimento.
```
$ curl localhost:8998/sessions
{"from":0,"total":0,"sessions":[]}
```
## Etapa 4: executar um fragmento de script simples em um parágrafo do caderno
Agora seu caderno no JupyterLab deve funcionar com seu endpoint de desenvolvimento. Digite o seguinte fragmento de script no seu caderno e execute-o.
1. Verifique se o Spark está sendo executado com êxito. O comando a seguir instrui o Spark a calcular `1` e, em seguida, imprimir o valor.
```
spark.sql("select 1").show()
```
1. Verifique se a integração com o AWS Glue Data Catalog está funcionando. O comando a seguir lista as tabelas do Data Catalog.
```
spark.sql("show tables").show()
```
1. Verifique se um fragmento de script simples que usa as bibliotecas do AWS Glue funciona.
O script a seguir usa os metadados da tabela `persons_json` no AWS Glue Data Catalog para criar um `DynamicFrame` dos seus dados de exemplo. Em seguida, ele imprime a contagem de itens e o esquema desses dados.
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
# Create a Glue context
glueContext = GlueContext(SparkContext.getOrCreate())
# Create a DynamicFrame using the 'persons_json' table
persons_DyF = glueContext.create_dynamic_frame.from_catalog(database="legislators", table_name="persons_json")
# Print out information about *this* data
print("Count: ", persons_DyF.count())
persons_DyF.printSchema()
```
O resultado do script é o seguinte:
```
Count: 1961
root
|-- family_name: string
|-- name: string
|-- links: array
| |-- element: struct
| | |-- note: string
| | |-- url: string
|-- gender: string
|-- image: string
|-- identifiers: array
| |-- element: struct
| | |-- scheme: string
| | |-- identifier: string
|-- other_names: array
| |-- element: struct
| | |-- note: string
| | |-- name: string
| | |-- lang: string
|-- sort_name: string
|-- images: array
| |-- element: struct
| | |-- url: string
|-- given_name: string
|-- birth_date: string
|-- id: string
|-- contact_details: array
| |-- element: struct
| | |-- type: string
| | |-- value: string
|-- death_date: string
```
## Solução de problemas
+ Durante a instalação do JupyterLab, se o seu computador estiver atrás de um proxy corporativo ou firewall, você poderá encontrar erros de HTTP e SSL devido a perfis de segurança personalizados gerenciados por departamentos de TI corporativos.
Segue-se um exemplo de um erro típico que ocorre quando `conda` não consegue se conectar aos seus próprios repositórios:
```
CondaHTTPError: HTTP 000 CONNECTION FAILED for url
```
Isso pode acontecer porque sua empresa pode bloquear conexões com repositórios amplamente utilizados em comunidades de Python e JavaScript. Para obter mais informações, consulte [Installation Problems](https://jupyterlab.readthedocs.io/en/stable/getting_started/installation.html#installation-problems) (Problemas de instalação) no site do JupyterLab.
+ Se encontrar um erro de *conexão recusada* ao tentar se conectar ao seu endpoint de desenvolvimento, pode ser que você esteja usando um endpoint de desenvolvimento desatualizado. Tente criar um novo endpoint de desenvolvimento e se reconectar.
# Tutorial: usar um caderno do SageMaker AI com seu endpoint de desenvolvimento
No AWS Glue, você pode criar um endpoint de desenvolvimento e, depois, criar um caderno do SageMaker AI para ajudar a desenvolver os scripts de ETL e machine learning. Um caderno do SageMaker AI é uma instância de computação de machine learning totalmente gerenciada que executa a aplicação Caderno Jupyter.
1. No console do AWS Glue, escolha **Dev endpoints** para navegar até a lista de endpoints de desenvolvimento.
1. Marque a caixa de seleção ao lado do nome de um endpoint de desenvolvimento que você deseja usar e, no menu **Action (Ação)**, escolha **Create SageMaker notebook (Criar bloco de anotações do SageMaker)**.
1. Preencha a página **Create and configure a notebook (Criar e configurar um bloco de anotações)** da seguinte forma:
1. Insira um nome de bloco de anotações.
1. Em **Attach to development endpoint (Anexar ao endpoint de desenvolvimento)**, verifique o endpoint de desenvolvimento.
1. Crie ou escolha uma função do AWS Identity and Access Management (IAM).
A criação de uma função é recomendada. Se você usar uma função existente, verifique se ela tem as permissões necessárias. Para obter mais informações, consulte [Etapa 6: criar uma política do IAM para cadernos do SageMaker AI](create-sagemaker-notebook-policy.md).
1. (Opcional) Escolha uma VPC, uma sub-rede e um ou mais grupos de segurança.
1. (Opcional) Escolha uma chave de criptografia do AWS Key Management Service.
1. (Opcional) Adicione tags para a instância do bloco de anotações.
1. Escolha **Criar caderno**. Na página **Notebooks (Blocos de anotações)**, escolha o ícone de atualização no canto superior direito e continue até que o **Status** seja `Ready`.
1. Marque a caixa de seleção ao lado do nome do novo bloco de anotações e escolha **Open notebook (Abrir bloco de anotações)**.
1. Criar um novo bloco de anotações: na página **jupyter**, escolha **New (Novo)** e **Sparkmagic (PySpark)**.
Sua tela agora deve ser semelhante ao seguinte:
![\[A página jupyter tem uma barra de menus, barra de ferramentas e um campo de texto amplo no qual você pode inserir instruções.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/sagemaker-notebook.png)
1. (Opcional) Na parte superior da página, escolha **Untitled (Sem título)** e dê um nome ao bloco de anotações.
1. Para iniciar um aplicativo do Spark, digite o seguinte comando no bloco de anotações e, na barra de ferramentas, escolha **Run (Executar)**.
```
spark
```
Após um pequeno atraso, você deve ver a seguinte resposta:
![\[A resposta do sistema mostra o status do aplicativo do Spark e envia a seguinte mensagem: SparkSession disponível como 'spark'.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/spark-command-response.png)
1. Criar um quadro dinâmico e executar uma consulta: copie, cole e execute o seguinte código, que gera a contagem e o esquema da tabela `persons_json`.
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.transforms import *
glueContext = GlueContext(SparkContext.getOrCreate())
persons_DyF = glueContext.create_dynamic_frame.from_catalog(database="legislators", table_name="persons_json")
print ("Count: ", persons_DyF.count())
persons_DyF.printSchema()
```
# Tutorial: usar um shell REPL com seu endpoint de desenvolvimento
No AWS Glue, você pode criar um endpoint de desenvolvimento e, em seguida, invocar um shell REPL (Read–Evaluate–Print Loop) para executar o código PySpark de forma incremental. Dessa forma, você poderá depurar interativamente seus scripts de ETL antes de implantá-los.
Para usar um REPL em um endpoint de desenvolvimento, você precisa ter autorização para SSH no endpoint.
1. No computador local, abra uma janela de terminal que possa executar comandos SSH e cole o comando SSH editado. Execute o comando.
Pressupondo que você aceitou a versão 1.0 padrão do AWS Glue com Python 3 para o endpoint de desenvolvimento, a saída será assim:
```
Python 3.6.8 (default, Aug 2 2019, 17:42:44)
[GCC 4.8.5 20150623 (Red Hat 4.8.5-28)] on linux
Type "help", "copyright", "credits" or "license" for more information.
SLF4J: Class path contains multiple SLF4J bindings.
SLF4J: Found binding in [jar:file:/usr/share/aws/glue/etl/jars/glue-assembly.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: Found binding in [jar:file:/usr/lib/spark/jars/slf4j-log4j12-1.7.16.jar!/org/slf4j/impl/StaticLoggerBinder.class]
SLF4J: See http://www.slf4j.org/codes.html#multiple_bindings for an explanation.
SLF4J: Actual binding is of type [org.slf4j.impl.Log4jLoggerFactory]
Setting default log level to "WARN".
To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).
2019-09-23 22:12:23,071 WARN [Thread-5] yarn.Client (Logging.scala:logWarning(66)) - Neither spark.yarn.jars nor spark.yarn.archive is set, falling back to uploading libraries under SPARK_HOME.
2019-09-23 22:12:26,562 WARN [Thread-5] yarn.Client (Logging.scala:logWarning(66)) - Same name resource file:/usr/lib/spark/python/lib/pyspark.zip added multiple times to distributed cache
2019-09-23 22:12:26,580 WARN [Thread-5] yarn.Client (Logging.scala:logWarning(66)) - Same path resource file:///usr/share/aws/glue/etl/python/PyGlue.zip added multiple times to distributed cache.
2019-09-23 22:12:26,581 WARN [Thread-5] yarn.Client (Logging.scala:logWarning(66)) - Same path resource file:///usr/lib/spark/python/lib/py4j-src.zip added multiple times to distributed cache.
2019-09-23 22:12:26,581 WARN [Thread-5] yarn.Client (Logging.scala:logWarning(66)) - Same path resource file:///usr/share/aws/glue/libs/pyspark.zip added multiple times to distributed cache.
Welcome to
____ __
/ __/__ ___ _____/ /__
_\ \/ _ \/ _ `/ __/ '_/
/__ / .__/\_,_/_/ /_/\_\ version 2.4.3
/_/
Using Python version 3.6.8 (default, Aug 2 2019 17:42:44)
SparkSession available as 'spark'.
>>>
```
1. Digite a instrução `print(spark.version)` para ver se o shell REPL está funcionando corretamente. Se a versão Spark for exibida, seu REPL está pronto para ser usado.
1. Agora você pode tentar executar o seguinte script simples, linha por linha, no shell:
```
import sys
from pyspark.context import SparkContext
from awsglue.context import GlueContext
from awsglue.transforms import *
glueContext = GlueContext(SparkContext.getOrCreate())
persons_DyF = glueContext.create_dynamic_frame.from_catalog(database="legislators", table_name="persons_json")
print ("Count: ", persons_DyF.count())
persons_DyF.printSchema()
```
# Tutorial: configurar um PyCharm Professional com um endpoint de desenvolvimento
Este tutorial mostra como conectar o IDE Python [PyCharm Professional](https://www.jetbrains.com/pycharm/) sendo executado em sua máquina local a um endpoint de desenvolvimento para que você possa executar, depurar e testar de forma interativa scripts de ETL (extração, transformação e carregamento) do AWS Glue antes de implantá-los. As instruções e capturas de tela no tutorial são baseadas no PyCharm Professional versão 2019.3.
Para se conectar a um endpoint de desenvolvimento de forma interativa, você precisa ter PyCharm Professional instalado. Você não pode fazer isso usando a edição gratuita.
**nota**
O tutorial usa o Amazon S3 como a fonte dos dados. Se você quiser usar uma fonte de dados JDBC, execute o endpoint de desenvolvimento em uma nuvem privada virtual (VPC). Para se conectar com SSH a um endpoint de desenvolvimento em uma VPC, você deve criar um túnel SSH. Este tutorial não inclui instruções para criar um túnel SSH. Para obter informações sobre como usar o SSH para se conectar a um endpoint de desenvolvimento em uma VPC, consulte [Securely Connect to Linux Instances Running in a Private Amazon VPC](https://aws.amazon.com/blogs/security/securely-connect-to-linux-instances-running-in-a-private-amazon-vpc/) no blog de segurança da AWS.
**Topics**
+ [Conectar o PyCharm Professional a um endpoint de desenvolvimento](#dev-endpoint-tutorial-pycharm-connect)
+ [Implantar o script no endpoint de desenvolvimento](#dev-endpoint-tutorial-pycharm-deploy)
+ [Configurar um intérprete remoto](#dev-endpoint-tutorial-pycharm-interpreter)
+ [Executar seu script no endpoint de desenvolvimento](#dev-endpoint-tutorial-pycharm-debug-run)
## Conectar o PyCharm Professional a um endpoint de desenvolvimento
1. Crie um novo projeto Python puro no PyCharm, chamado `legislators`.
1. Crie um arquivo chamado `get_person_schema.py` no projeto com o seguinte conteúdo:
```
from pyspark.context import SparkContext
from awsglue.context import GlueContext
def main():
# Create a Glue context
glueContext = GlueContext(SparkContext.getOrCreate())
# Create a DynamicFrame using the 'persons_json' table
persons_DyF = glueContext.create_dynamic_frame.from_catalog(database="legislators", table_name="persons_json")
# Print out information about this data
print("Count: ", persons_DyF.count())
persons_DyF.printSchema()
if __name__ == "__main__":
main()
```
1. Execute um destes procedimentos:
+ Para o AWS Glue versão 0.9, faça download do arquivo da biblioteca Python do AWS Glue, `PyGlue.zip`, em `https://s3.amazonaws.com/aws-glue-jes-prod-us-east-1-assets/etl/python/PyGlue.zip` para um local conveniente na sua máquina local.
+ Para o AWS Glue versão 1.0 ou versões posteriores, faça download do arquivo da biblioteca Python do AWS Glue, `PyGlue.zip`, em `https://s3.amazonaws.com/aws-glue-jes-prod-us-east-1-assets/etl-1.0/python/PyGlue.zip` para um local conveniente na sua máquina local.
1. Adicione o `PyGlue.zip` como raiz de conteúdo do seu projeto no PyCharm:
+ No PyCharm, escolha **File**, **Settings** para abrir a caixa de diálogo **Settings**. Você também pode pressionar . `Ctrl+Alt+S`.)
+ Expanda o projeto `legislators` e escolha **Project Structure**. Em seguida, escolha **\$1 Add Content Root** no painel direito.
+ Navegue até o local em que você salvou `PyGlue.zip`, selecione-o, e escolha **Apply**.
A tela **Settings** deve ser semelhante à seguinte:
![\[A tela Settings do PyCharm com o PyGlue.zip adicionado como uma raiz de conteúdo.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/PyCharm_AddContentRoot.png)
Mantenha a caixa de diálogo **Settings** aberta depois de selecionar **Apply**.
1. Configure as opções de implantação para fazer upload do script local no seu endpoint de desenvolvimento usando SFTP (esse recurso está disponível somente no PyCharm Professional):
+ Na caixa de diálogo **Settings**, expanda a seção **Build, Execution, Deployment**. Escolha a subseção **Deployment**.
+ Escolha o ícone **\$1** na parte superior do painel central para adicionar um novo servidor. Defina o **Type (Tipo)** como `SFTP` e dê um nome a ele.
+ Defina o **SFTP host (Host SFTP)** como **Public address (Endereço público)** do endpoint de desenvolvimento, conforme listado na página de detalhes. Escolha o nome do endpoint de desenvolvimento no console do AWS Glue para exibir a página de detalhes. Para um endpoint de desenvolvimento em execução em uma VPC, defina o **SFTP host (Host SFTP)** como o endereço do host e a porta local do túnel SSH como o endpoint de desenvolvimento.
+ Defina **User name** como `glue`.
+ Defina **Auth type** como **Key pair (OpenSSH or Putty)**. Defina **Private key file** (Arquivo de chave privada) navegando até o local em que o arquivo de chave privada do endpoint de desenvolvimento está localizado. Observe que PyCharm só é compatível com tipos de chave DSA, RSA e ECDSA OpenSSH, e não aceita chaves no formato privado de Putty. Você pode usar uma versão atualizada de `ssh-keygen` para gerar um tipo de par de chaves aceito pelo PyCharm, usando uma sintaxe como a seguinte:
```
ssh-keygen -t rsa -f -C ""
```
+ Escolha **Test connection (Conexão de teste)** e permita que a conexão seja testada. Se a conexão for concluída com sucesso, escolha **Apply**.
A tela **Settings** agora deve ser semelhante à seguinte:
![\[A tela Settings do PyCharm com servidor SFTP definido.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/PyCharm_SFTP.png)
Novamente, mantenha a caixa de diálogo **Settings** aberta depois de selecionar **Apply**.
1. Mapeie o diretório local até um diretório remoto para implantação:
+ No painel direito da página **Deployment**, escolha a guia central na parte superior, nomeada **Mappings**.
+ Na coluna **Deployment Path**, insira um caminho abaixo de `/home/glue/scripts/` para implantação do caminho do seu projeto. Por exemplo: `/home/glue/scripts/legislators`.
+ Selecione **Aplicar**.
A tela **Settings** agora deve ser semelhante à seguinte:
![\[A tela Settings do PyCharm depois do mapeamento da implantação.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/PyCharm_Mapping.png)
Escolha **OK** para fechar a caixa de diálogo **Settings (Configurações)**.
## Implantar o script no endpoint de desenvolvimento
1. Escolha **Tools (Ferramentas)**, **Deployment (Implantação)** e o nome para o qual você configurou seu endpoint de desenvolvimento, conforme mostrado na seguinte imagem:
![\[O item de menu para a implantação do seu script.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/PyCharm_Deploy.png)
Depois que seu script for implantado, a parte inferior da tela exibirá o seguinte:
![\[Parte inferior da tela PyCharm depois de uma implantação bem-sucedida.\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/PyCharm_Deployed.png)
1. Na barra de menus, escolha **Tools (Ferramentas)**, **Deployment (Implantação)**, **Automatic Upload (always) (Upload automático (sempre))**. Verifique se uma marca de seleção aparece ao lado de **Automatic Upload (always) (Upload automático (sempre))**.
Quando essa opção está habilitada, o PyCharm carrega automaticamente os arquivos alterados no endpoint de desenvolvimento.
## Configurar um intérprete remoto
Configure o PyCharm para usar o intérprete Python no endpoint de desenvolvimento.
1. No menu **File (Arquivo)**, escolha **Settings (Configurações)**.
1. Expanda os **legislators (legisladores)** do projeto e escolha **Project Interpreter (Intérprete do projeto)**.
1. Escolha o ícone de engrenagem ao lado da lista **Project Interpreter (Intérprete do projeto)** e escolha **Add (Adicionar)**.
1. Na caixa de diálogo **Add Python Interpreter (Adicionar intérprete Python)**, no painel esquerdo, escolha **SSH Interpreter (Intérprete SSH)**.
1. Escolha **Existing server configuration (Configuração de servidor existente)** e, na lista **Deployment configuration (Configuração de implantação)**, escolha sua configuração.
Sua tela deve ser semelhante à seguinte imagem.
![\[No painel esquerdo, SSH Interpreter (Intérprete SSH) é selecionado e, no painel direito, o botão de opção Existing server configuration (Configuração do servidor existente) é selecionado. O campo Deployment configuration (Configuração de implantação) contém o nome da configuração e a mensagem "Remote SDK is saved in IDE settings, so it needs the deployment server to be saved there too. Which do you prefer?" (O SDK remoto é salvo nas configurações do IDE e, portanto, ele precisa que o servidor de implantação também seja salvo lá. O que você prefere?) Veja a seguir as opções abaixo dessa mensagem: "Create copy of this deployment server in IDE settings" (Criar cópia deste servidor de implantação nas configurações do IDE) e "Move this server to IDE settings" (Mover este servidor para configurações do IDE).\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/images/PyCharm_Interpreter1.png)
1. Escolha **Move this server to IDE settings (Mover este servidor para configurações do IDE)** e **Next (Avançar)**.
1. No campo **Interpreter (Intérprete)**, altere o caminho para ` /usr/bin/gluepython` se você estiver usando Python 2 ou para `/usr/bin/gluepython3` se estiver usando Python 3. Em seguida, escolha **Finish (Concluir)**.
## Executar seu script no endpoint de desenvolvimento
Para executar o script:
+ No painel esquerdo, clique com o botão direito do mouse no nome do arquivo e escolha **Run '**' (Executar )**.
Após uma série de mensagens, a saída final deve mostrar a contagem e o esquema.
```
Count: 1961
root
|-- family_name: string
|-- name: string
|-- links: array
| |-- element: struct
| | |-- note: string
| | |-- url: string
|-- gender: string
|-- image: string
|-- identifiers: array
| |-- element: struct
| | |-- scheme: string
| | |-- identifier: string
|-- other_names: array
| |-- element: struct
| | |-- lang: string
| | |-- note: string
| | |-- name: string
|-- sort_name: string
|-- images: array
| |-- element: struct
| | |-- url: string
|-- given_name: string
|-- birth_date: string
|-- id: string
|-- contact_details: array
| |-- element: struct
| | |-- type: string
| | |-- value: string
|-- death_date: string
Process finished with exit code 0
```
Agora você está pronto para depurar seu script remotamente no endpoint de desenvolvimento.
# Configuração avançada: compartilhar endpoints de desenvolvimento entre vários usuários
Esta seção explica como você pode aproveitar os endpoints de desenvolvimento com cadernos do SageMaker em casos de uso típicos a fim de compartilhar endpoints de desenvolvimento entre vários usuários.
## Configuração de locação única
Em casos de uso de locatário único, para simplificar a experiência do desenvolvedor e para evitar contenção por recursos, é recomendável que cada desenvolvedor use seu próprio endpoint de desenvolvimento dimensionado para o projeto em que está trabalhando. Isso também simplifica as decisões relacionadas ao tipo de operador e à contagem de DPU, deixando-as à discrição do desenvolvedor e do projeto em que estão trabalhando.
Você não precisará cuidar da alocação de recursos, a menos que execute vários arquivos de caderno simultaneamente. Se você executar um código em vários arquivos de caderno ao mesmo tempo, várias sessões do Livy serão iniciadas simultaneamente. Para segregar configurações de cluster do Spark a fim de executar várias sessões do Livy ao mesmo tempo, você pode seguir as etapas que são introduzidas em casos de uso multilocatário.
Por exemplo, se o endpoint de desenvolvimento tiver dez operadores e o tipo de operador for ` G.1X`, então você terá nove executores do Spark e todo o cluster terá 90G de memória de executor, uma vez que cada executor terá 10G de memória.
Independentemente do tipo de operador especificado, a alocação dinâmica de recursos do Spark será ativada. Se um conjunto de dados for grande o suficiente, o Spark pode alocar todos os executores em uma única sessão do Livy, já que `spark.dynamicAllocation.maxExecutors` não é definido por padrão. Isso significa que outras sessões do Livy no mesmo endpoint de desenvolvimento esperarão para iniciar novos executores. Se o conjunto de dados for pequeno, o Spark poderá alocar executores em várias sessões do Livy ao mesmo tempo.
**nota**
Para obter mais informações sobre como os recursos são alocados em diferentes casos de uso e como você define uma configuração para modificar o comportamento, consulte [Configuração avançada: compartilhar endpoints de desenvolvimento entre vários usuários](#dev-endpoint-sharing).
### Configuração de locação múltipla
**nota**
Observe que os endpoints de desenvolvimento são destinados a emular o ambiente de ETL do AWS Glue como um ambiente de locatário único. Embora o uso de multilocatário seja possível, esse é um caso de uso avançado e é recomendado que a maioria dos usuários mantenha um padrão de locação única para cada endpoint de desenvolvimento.
Em casos de uso multilocatário, talvez seja necessário cuidar da alocação de recursos. O principal fator é o número de usuários simultâneos que usam um caderno Jupyter ao mesmo tempo. Se sua equipe estiver distribuída ao redor do mundo de forma a seguir um fluxo de trabalho de 24 horas por dia e houver apenas um usuário do Jupyter em cada fuso horário, então o número de usuários simultâneos será apenas um e você não precisará se preocupar com a alocação de recursos. No entanto, se seu caderno for compartilhado entre vários usuários e cada um enviar código de forma ad-hoc, então você precisará considerar os pontos abaixo.
Para particionar recursos de cluster do Spark entre vários usuários, você pode usar as configurações do SparkMagic. Há duas maneiras diferentes de configurar o SparkMagic.
#### (A) Usar a diretiva %%configure -f
Se você quiser modificar a configuração por sessão do Livy a partir do caderno, poderá executar a diretiva `%%configure -f` no parágrafo do caderno.
Por exemplo, se você deseja executar a aplicação Spark em cinco executores, pode executar o seguinte comando no parágrafo do caderno.
```
%%configure -f
{"numExecutors":5}
```
Em seguida, você verá apenas cinco executores em execução para o trabalho na IU do Spark.
Recomendamos limitar o número máximo de executores para alocação dinâmica de recursos.
```
%%configure -f
{"conf":{"spark.dynamicAllocation.maxExecutors":"5"}}
```
#### (B) Modificar o arquivo Config do SparkMagic
O SparkMagic funciona com base na [API do Livy](https://livy.incubator.apache.org/docs/latest/rest-api.html). O SparkMagic cria sessões do Livy com configurações como: `driverMemory`, ` driverCores`, `executorMemory`, `executorCores`, ` numExecutors`, `conf` etc. Esses são os principais fatores que determinam a quantidade de recursos consumidos de todo o cluster do Spark. O SparkMagic permite que você forneça um arquivo de configuração para especificar os parâmetros que são enviados ao Livy. Você pode ver um arquivo de configuração de exemplo neste [repositório do GitHub](https://github.com/jupyter-incubator/sparkmagic/blob/master/sparkmagic/example_config.json).
Se você quiser modificar a configuração em todas as sessões do Livy a partir de um caderno, poderá modificar `/home/ec2-user/.sparkmagic/config.json` para adicionar `session_config`.
Para modificar o arquivo de configuração em uma instância de cadernos do SageMaker, siga estas etapas.
1. Abra um caderno do SageMaker.
1. Abra o kernel do terminal.
1. Execute os seguintes comandos:
```
sh-4.2$ cd .sparkmagic
sh-4.2$ ls
config.json logs
sh-4.2$ sudo vim config.json
```
Por exemplo, você pode adicionar estas linhas a ` /home/ec2-user/.sparkmagic/config.json` e reiniciar o kernel do Jupyter a partir do caderno.
```
"session_configs": {
"conf": {
"spark.dynamicAllocation.maxExecutors":"5"
}
},
```
### Diretrizes e práticas recomendadas
Para evitar esse tipo de conflito de recursos, você pode usar algumas abordagens básicas, como:
+ Ter um cluster do Spark maior, aumentando `NumberOfWorkers` (escalonando horizontalmente) e atualizando `workerType`(escalonando verticalmente)
+ Alocar menos recursos por usuário (menos recursos por sessão do Livy)
Sua abordagem dependerá do seu caso de uso. Se você tiver um endpoint de desenvolvimento maior e não houver uma grande quantidade de dados, a possibilidade de um conflito de recursos diminuirá significativamente porque o Spark pode alocar recursos com base em uma estratégia de alocação dinâmica.
Como descrito acima, o número máximo de executores do Spark é calculado automaticamente pela combinação de DPU (ou `NumberOfWorkers`) e tipo de operador. Cada aplicação do Spark inicia um driver e vários executores. Para calcular, você precisará de ` NumberOfWorkers` = `NumberOfExecutors + 1`. A matriz abaixo explica quanta capacidade você precisa em seu endpoint de desenvolvimento com base no número de usuários simultâneos.
****
| Número de usuários simultâneos de cadernos | Número de executores do Spark que você deseja alocar por usuário | NumberOfWorkers (número de operadores) total para seu endpoint de desenvolvimento |
| --- | --- | --- |
| 3 | 5 | 18 |
| 10 | 5 | 60 |
| 50 | 5 | 300 |
Se você quiser alocar menos recursos por usuário, ` spark.dynamicAllocation.maxExecutors` (ou `numExecutors`) seria o parâmetro mais fácil de configurar como um parâmetro de sessão do Livy. Se você definir a configuração abaixo em `/home/ec2-user/.sparkmagic/config.json`, então o SparkMagic atribuirá um máximo de cinco executores por sessão do Livy. Isso ajudará a segregar recursos por sessão do Livy.
```
"session_configs": {
"conf": {
"spark.dynamicAllocation.maxExecutors":"5"
}
},
```
Suponha que haja um endpoint de desenvolvimento com 18 operadores (G.1X) e que haja três usuários de cadernos simultâneos. Se a configuração da sua sessão tiver ` spark.dynamicAllocation.maxExecutors=5`, então cada usuário poderá fazer uso de um driver e cinco executores. Não haverá conflitos de recursos, mesmo quando você executar vários parágrafos do caderno ao mesmo tempo.
#### Trade-offs
Com esta configuração de sessão `"spark.dynamicAllocation.maxExecutors":"5"`, você poderá evitar erros de conflito de recursos e não precisará aguardar a alocação de recursos quando houver acessos simultâneos de usuários. No entanto, mesmo quando há muitos recursos livres (por exemplo, não há outros usuários simultâneos), o Spark não pode atribuir mais de cinco executores à sessão do Livy.
#### Outras observações
É uma boa prática interromper o kernel do Jupyter quando você parar de usar um caderno. Isso liberará recursos e outros usuários de cadernos poderão usar esses recursos imediatamente, sem aguardar a expiração do kernel (desligamento automático).
### Problemas comuns
Mesmo ao seguir as diretrizes, você pode enfrentar certos problemas.
#### Sessão não encontrada
Ao tentar executar um parágrafo do caderno mesmo que sua sessão do Livy já tenha terminado, você verá a mensagem abaixo. Para ativar a sessão do Livy, você precisa reiniciar o kernel do Jupyter escolhendo **Kernel** > **Restart** (Reiniciar) no menu do Jupyter e, em seguida, executar o parágrafo do caderno novamente.
```
An error was encountered:
Invalid status code '404' from http://localhost:8998/sessions/13 with error payload: "Session '13' not found."
```
#### Não há recursos suficientes do YARN
Ao tentar executar um parágrafo do caderno mesmo que o cluster do Spark não tenha recursos suficientes para iniciar uma nova sessão do Livy, você verá a mensagem abaixo. Muitas vezes, você pode evitar esse problema seguindo as diretrizes, no entanto, ainda haverá a possibilidade de você encontrar esse problema. Para contornar o problema, você pode conferir se há sessões ativas e desnecessárias do Livy. Se houver sessões do Livy desnecessárias, você precisará terminá-las para liberar os recursos do cluster. Consulte a próxima seção para obter detalhes.
```
Warning: The Spark session does not have enough YARN resources to start.
The code failed because of a fatal error:
Session 16 did not start up in 60 seconds..
Some things to try:
a) Make sure Spark has enough available resources for Jupyter to create a Spark context.
b) Contact your Jupyter administrator to make sure the Spark magics library is configured correctly.
c) Restart the kernel.
```
### Monitoramento e depuração
Esta seção descreve técnicas para monitorar recursos e sessões.
#### Monitorar e depurar a alocação de recursos do cluster
Você pode observar a interface do usuário do Spark para monitorar quantos recursos são alocados por sessão do Livy e quais são as configurações efetivas do Spark no trabalho. Para habilitar a interface do usuário do Spark, consulte [Habilitar a interface do usuário Web do Apache Spark para endpoints de desenvolvimento](https://docs.aws.amazon.com/glue/latest/dg/monitor-spark-ui-dev-endpoints.html).
(Opcional) Se você precisar de uma visualização em tempo real da interface do usuário do Spark, poderá configurar um túnel SSH para o servidor de histórico do Spark em execução no cluster do Spark.
```
ssh -i -N -L 8157::18080 glue@
```
Você pode abrir http://localhost:8157 no navegador para visualizar a interface do usuário do Spark localmente.
#### Liberar sessões do Livy desnecessárias
Reveja estes procedimentos para encerrar quaisquer sessões desnecessárias do Livy a partir de um caderno ou de um cluster do Spark.
**(a). Terminar sessões do Livy a partir de um caderno**
Você pode desligar o kernel em um caderno Jupyter para terminar sessões do Livy desnecessárias.
**(b). Terminar sessões do Livy a partir de um cluster do Spark**
Se houver sessões do Livy desnecessárias que ainda estejam em execução, você pode terminá-las no cluster do Spark.
Como pré-requisito para executar esse procedimento, você precisa configurar sua chave SSH pública para o seu endpoint de desenvolvimento.
Para fazer login no cluster do Spark, execute o seguinte comando:
```
$ ssh -i glue@
```
Você pode executar o seguinte comando para ver as sessões do Livy ativas:
```
$ yarn application -list
20/09/25 06:22:21 INFO client.RMProxy: Connecting to ResourceManager at ip-255-1-106-206.ec2.internal/172.38.106.206:8032
Total number of applications (application-types: [] and states: [SUBMITTED, ACCEPTED, RUNNING]):2
Application-Id Application-Name Application-Type User Queue State Final-State Progress Tracking-URL
application_1601003432160_0005 livy-session-4 SPARK livy default RUNNING UNDEFINED 10% http://ip-255-1-4-130.ec2.internal:41867
application_1601003432160_0004 livy-session-3 SPARK livy default RUNNING UNDEFINED 10% http://ip-255-1-179-185.ec2.internal:33727
```
Em seguida, você pode desligar a sessão do Livy com o seguinte comando:
```
$ yarn application -kill application_1601003432160_0005
20/09/25 06:23:38 INFO client.RMProxy: Connecting to ResourceManager at ip-255-1-106-206.ec2.internal/255.1.106.206:8032
Killing application application_1601003432160_0005
20/09/25 06:23:39 INFO impl.YarnClientImpl: Killed application application_1601003432160_0005
```
# Gerenciar cadernos
**nota**
Os endpoints de desenvolvimento só são compatíveis com as versões do AWS Glue anteriores à 2.0. Para um ambiente interativo onde você possa criar e testar scripts de ETL, use [Cadernos no AWS Glue Studio](https://docs.aws.amazon.com/glue/latest/ug/notebooks-chapter.html).
Um caderno permite desenvolver e testar interativamente seus scripts de ETL (extrair, transformar e carregar) em um endpoint de desenvolvimento. O AWS Glue fornece uma interface para cadernos Jupyter do SageMaker AI. Com o AWS Glue, é possível criar e gerenciar cadernos do SageMaker AI. Você também pode abrir cadernos do SageMaker AI no console do AWS Glue.
Além disso, você pode usar o Apache Spark com o SageMaker AI em endpoints de desenvolvimento do AWS Glue que oferecem suporte ao SageMaker AI (mas não a trabalhos de ETL do AWS Glue). O SageMaker Spark é uma biblioteca de código aberto do Apache Spark para SageMaker AI. Para obter mais informações, consulte [Uso do Apache Spark com o Amazon SageMaker](https://docs.aws.amazon.com/sagemaker/latest/dg/apache-spark.html).
| Região | Código |
| --- | --- |
| O gerenciamento de cadernos do SageMaker AI com endpoints de desenvolvimento do AWS Glue está disponível nas seguintes regiões da AWS: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/glue/latest/dg/notebooks-with-glue.html) |
| Leste dos EUA (Ohio) | `us-east-2` |
| Leste dos EUA (Norte da Virgínia) | `us-east-1` |
| Oeste dos EUA (Norte da Califórnia) | `us-west-1` |
| Oeste dos EUA (Oregon) | `us-west-2` |
| Ásia-Pacífico (Tóquio) | `ap-northeast-1` |
| Ásia-Pacífico (Seul) | `ap-northeast-2` |
| Ásia-Pacífico (Mumbai) | `ap-south-1` |
| Ásia-Pacífico (Singapura) | `ap-southeast-1` |
| Ásia-Pacífico (Sydney) | `ap-southeast-2` |
| Canadá (Central) | `ca-central-1` |
| Europa (Frankfurt) | `eu-central-1` |
| Europa (Irlanda) | `eu-west-1` |
| Europa (Londres) | `eu-west-2` |
**Topics**