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á.
# Recomendações para escolher a ferramenta certa de preparação de dados em SageMaker IA
A preparação de dados em machine learning se refere ao processo de coleta, pré-processamento e organização de dados brutos para torná-los adequados para análise e modelagem. Essa etapa garante que os dados estejam em um formato a partir do qual os algoritmos de machine learning possam aprender com eficácia. As tarefas de preparação de dados podem incluir processar valores ausentes, remover valores discrepantes, escalar atributos, codificar variáveis categóricas, avaliar possíveis vieses e tomar medidas para mitigá-los, dividindo dados em conjuntos de treinamento e teste, rotulando e outras transformações necessárias para otimizar a qualidade e a usabilidade dos dados para tarefas subsequentes de machine learning.
## Escolha um atributo
Há três casos de uso principais para *preparação de dados* com a Amazon SageMaker AI. Escolha o [caso de uso](#data-prep-choose-use-cases) que se alinha com seus requisitos e, em seguida, consulte o [atributo recomendado](#data-prep-choose-recommended) correspondente.
### Casos de uso
A seguir estão os principais casos de uso ao realizar a preparação de dados para Machine Learning.
+ **Caso de uso 1**: Para aqueles que preferem uma interface visual, a SageMaker IA fornece maneiras de explorar, preparar e criar recursos para o treinamento de modelos por meio de um point-and-click ambiente.
+ **Caso de uso 2**: Para usuários familiarizados com a codificação que desejam mais flexibilidade e controle sobre a preparação de dados, a SageMaker IA integra ferramentas em seus ambientes de codificação para exploração, transformações e engenharia de recursos.
+ **Caso de uso 3**: Para usuários focados na preparação escalável de dados, a SageMaker IA oferece recursos sem servidor que aproveitam o ecossistema Hadoop/Spark para processamento distribuído de big data.
### Recursos recomendados
A tabela a seguir descreve as principais considerações e compensações dos recursos de SageMaker IA relacionados a cada caso de uso de preparação de dados para aprendizado de máquina. Para começar, identifique o caso de uso que se alinha aos seus requisitos e navegue até o recurso de SageMaker IA recomendado.
| Descritor | Caso de uso 1 | Caso de uso 2 | Caso de uso 3 |
| --- | --- | --- | --- |
| SageMaker Recurso de IA | [Data Wrangler no Amazon Canvas](canvas-data-prep.md) SageMaker | [Preparação de dados com SQL no Studio](sagemaker-sql-extension.md) | Aplicações [Preparar dados usando o EMR Sem Servidor](studio-notebooks-emr-serverless.md) no Studio |
| Description | SageMaker O Canvas é um ambiente visual de baixo código para criar, treinar e implantar modelos de aprendizado de máquina em SageMaker IA. Sua ferramenta integrada Data Wrangler permite aos usuários combinar, transformar e limpar conjuntos de dados por meio de interações. point-and-click | A extensão SQL no Studio permite que os usuários se conectem ao Amazon Redshift, Snowflake, Athena e Amazon S3 para criar consultas SQL ad-hoc e visualizar resultados em notebooks. JupyterLab A saída dessas consultas pode ser manipulada usando Python e Pandas para processamento, visualização e transformação adicionais em formatos utilizáveis para o desenvolvimento de modelos de machine learning. | A integração entre o EMR Serverless e o SageMaker Amazon Studio fornece um ambiente escalável sem servidor para preparação de dados em grande escala para aprendizado de máquina usando estruturas de código aberto, como Apache Spark e Apache Hive. Os usuários podem acessar as aplicações e dados do EMR Sem Servidor diretamente de seus cadernos do Studio para realizar tarefas de preparação de dados em grande escala. |
| Otimizado para | Usando uma interface visual na qual você pode: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/data-prep.html) Otimizado para tarefas de dados tabulares, como processar valores ausentes, codificar variáveis categóricas e aplicar transformações de dados. | Para usuários cujos dados residem no Amazon Redshift, Snowflake, Athena ou [Amazon S3](studio-sqlexplorer-athena-s3-quickstart.md) e desejam combinar SQL exploratório e Python para análise e preparação de dados sem a necessidade de aprender Spark. | Para usuários que preferem uma experiência sem servidor com provisionamento e encerramento automáticos de recursos para escalar cargas de trabalho interativas interativas de curta duração ou intermitentes que giram em torno do Apache Spark e, ao mesmo tempo, aproveitam os recursos de aprendizado de máquina da IA. SageMaker |
| Considerações | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/data-prep.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/data-prep.html) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/data-prep.html) |
| Ambiente recomendado | [Começando a usar o SageMaker Canvas](canvas-getting-started.md) | [Executar o Studio](studio-updated-launch.md#studio-updated-launch-prereq) | [Executar o Studio](studio-updated-launch.md#studio-updated-launch-prereq) |
### Opções adicionais
SageMaker A IA oferece as seguintes opções adicionais para preparar seus dados para uso em modelos de aprendizado de máquina.
+ [Preparação de dados usando o Amazon EMR](studio-notebooks-emr-cluster.md): Para tarefas de processamento de dados de longa duração, intensivas em computação e em grande escala, considere usar clusters do Amazon EMR do Studio. SageMaker Os clusters do Amazon EMR são projetados para lidar com paralelização massiva e podem ser escalados para centenas ou milhares de nós, o que os torna adequados para workloads de big data que exigem estruturas como Apache Spark, Hadoop, Hive e Presto. A integração do Amazon EMR com o SageMaker Studio permite que você aproveite a escalabilidade e o desempenho do Amazon EMR, mantendo a experimentação completa de ML, o treinamento e a implantação de modelos centralizados e gerenciados no ambiente do Studio. SageMaker
+ [Prepare dados usando sessões interativas Glue](studio-notebooks-glue.md): você pode usar o mecanismo sem servidor baseado no Apache Spark a partir de sessões AWS Glue interativas para agregar, transformar e preparar dados de várias fontes no Studio. SageMaker
+ [Identifique o viés nos dados de treinamento]() usando as tarefas de processamento do Amazon SageMaker SageMaker Clarify: o Clarify analisa seus dados e detecta possíveis vieses em várias facetas. Por exemplo, você pode usar a API Clarify no Studio para detectar se seus dados de treinamento contêm representações desequilibradas ou tendências de rotulagem entre grupos, como gênero, raça ou idade. A Clarify pode ajudá-lo a identificar esses preconceitos antes de treinar um modelo para evitar a propagação de preconceitos nas predição do modelo.
+ [Crie, armazene e compartilhe recursos](): a Amazon SageMaker Feature Store otimiza a descoberta e a reutilização de recursos selecionados para aprendizado de máquina. Ele fornece um repositório centralizado para armazenar dados de atributos que podem ser pesquisados e recuperados para treinamento de modelos. Armazenar atributos em um formato padronizado permite a reutilização em projetos de ML. O Feature Store gerencia todo o ciclo de vida dos atributos, incluindo rastreamento de linhagem, estatísticas e trilhas de auditoria para engenharia de atributos de machine learning escalável e governada.
+ [Rotule os dados com um human-in-the-loop](data-label.md): Você pode usar o SageMaker Ground Truth para gerenciar os fluxos de trabalho de rotulagem de dados de seus conjuntos de dados de treinamento.
+ [Use a API SageMaker de processamento](processing-job.md)[: depois de realizar a análise exploratória de dados e criar suas etapas de transformação de dados, você pode produzir seu código de transformação usando [trabalhos de processamento de SageMaker IA](processing-job.md) e automatizar seu fluxo de trabalho de preparação usando pipelines de construção de modelos. SageMaker ](pipelines.md)
# Preparação de dados com SQL no Studio
O Amazon SageMaker Studio fornece uma extensão SQL integrada. Essa extensão permite que cientistas de dados realizem tarefas como amostragem, análise exploratória e engenharia de recursos diretamente em seus JupyterLab notebooks. Ele aproveita as AWS Glue conexões para manter um catálogo centralizado de fontes de dados. O catálogo armazena metadados sobre várias fontes de dados. Por meio desse ambiente SQL, os cientistas de dados podem navegar pelos catálogos de dados, explorar seus dados, criar consultas SQL complexas e processar ainda mais os resultados em Python.
Esta seção explica como configurar a extensão SQL no Studio. Ele descreve os recursos habilitados por essa integração SQL e fornece instruções para executar consultas SQL em JupyterLab notebooks.
Para habilitar a análise de dados SQL, os administradores devem primeiro configurar AWS Glue as conexões com as fontes de dados relevantes. Essas conexões permitem que os cientistas de dados acessem facilmente conjuntos de dados autorizados internamente. JupyterLab
Além das AWS Glue conexões configuradas pelo administrador, a extensão SQL permite que cientistas de dados individuais criem suas próprias conexões de fonte de dados. Essas conexões criadas pelo usuário podem ser gerenciadas de forma independente e definidas de acordo com o perfil do usuário por meio de políticas de controle de acesso baseadas em tags. Esse modelo de conexão de dois níveis, com conexões configuradas pelo administrador e criadas pelo usuário, oferece aos cientistas de dados um acesso mais amplo aos dados necessários para as tarefas de análise e modelagem. Os usuários podem configurar as conexões necessárias com suas próprias fontes de dados na interface de usuário (UI) do JupyterLab ambiente, sem depender apenas das conexões centralizadas estabelecidas pelo administrador.
**Importante**
O recurso de criação de conexões definidas pelo usuário está disponível como um conjunto de bibliotecas independentes no PyPI. Para usar essa funcionalidade, você precisa instalar as seguintes bibliotecas em seu JupyterLab ambiente:
[amazon-sagemaker-sql-editor](https://pypi.org/project/amazon-sagemaker-sql-editor/)
[amazon-sagemaker-sql-execution](https://pypi.org/project/amazon-sagemaker-sql-execution/)
[amazon-sagemaker-sql-magic](https://pypi.org/project/amazon-sagemaker-sql-magic/)
Você pode instalar essas bibliotecas executando os seguintes comandos em seu JupyterLab terminal:
```
pip install amazon-sagemaker-sql-editor>=0.1.13
pip install amazon-sagemaker-sql-execution>=0.1.6
pip install amazon-sagemaker-sql-magic>=0.1.3
```
Depois de instalar as bibliotecas, você precisará reiniciar o JupyterLab servidor para que as alterações entrem em vigor.
```
restart-jupyter-server
```
Com o acesso configurado, JupyterLab os usuários podem:
+ Visualizar e navegar em fontes de dados pré-configuradas.
+ Pesquisar, filtrar e inspecionar elementos de informações do banco de dados, como tabelas, esquemas e colunas.
+ Gerar automaticamente os parâmetros de conexão para uma fonte de dados.
+ Criar consultas SQL complexas usando os atributos de realce de sintaxe, preenchimento automático e formatação SQL do editor de SQL da extensão.
+ Execute instruções SQL a partir de células do JupyterLab notebook.
+ Recupere os resultados das consultas SQL pandas DataFrames para processamento adicional, visualização e outras tarefas de aprendizado de máquina.
Você pode acessar a extensão escolhendo o ícone da extensão SQL (![\[Icon of the SQL extension feature in JupyterLab.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/sqlexplorer/sqlexplorer-icon.png)) no painel de navegação esquerdo do seu JupyterLab aplicativo no Studio. Passar o mouse sobre o ícone exibe a dica da ferramenta *Data Discovery*.
**Importante**
A JupyterLab imagem no SageMaker Studio contém a extensão SQL por padrão, começando com o [SageMaker AI Distribution](https://github.com/aws/sagemaker-distribution) 1.6. A extensão funciona somente com Python e SparkMagic kernels.
A interface de usuário da extensão para explorar conexões e dados só está disponível JupyterLab no Studio. É compatível com [Amazon Redshift](https://aws.amazon.com/redshift/), [Amazon Athena](https://aws.amazon.com/athena/) e [Snowflake](https://www.snowflake.com/en/).
+ Se você for um administrador que deseja criar conexões genéricas com fontes de dados para a extensão de SQL, siga estas etapas:
1. Habilite a comunicação de rede entre o domínio do Studio e as fontes de dados às quais você deseja se conectar. Para saber quais são os requisitos de rede, consulte [Configurar o acesso à rede entre o Studio e as fontes de dados (para administradores)](sagemaker-sql-extension-networking.md).
1. Consulte [Criar segredos no Secrets Manager para credenciais de acesso de banco de dados](sagemaker-sql-extension-glue-connection-secrets.md) para verificar as propriedades e instruções de conexão para criar um segredo para sua fonte de dados.
1. Crie as AWS Glue conexões com suas fontes de dados em[Crie AWS Glue conexões (para administradores)](sagemaker-sql-extension-datasources-glue-connection.md).
1. Conceda à função de execução de seu SageMaker domínio ou perfis de usuário as permissões necessárias em[Configurar as permissões do IAM para acessar as fontes de dados (para administradores)](sagemaker-sql-extension-datasources-connection-permissions.md).
+ Se você é cientista de dados e deseja criar suas próprias conexões com fontes de dados para a extensão de SQL, siga estas etapas:
1. Faça com que seu administrador:
+ Habilite a comunicação de rede entre o domínio do Studio e as fontes de dados às quais você deseja se conectar. Para saber quais são os requisitos de rede, consulte [Configurar o acesso à rede entre o Studio e as fontes de dados (para administradores)](sagemaker-sql-extension-networking.md).
+ Conceda à função de execução de seu SageMaker domínio ou perfis de usuário as permissões necessárias em[Configurar as permissões do IAM para acessar as fontes de dados (para administradores)](sagemaker-sql-extension-datasources-connection-permissions.md).
**nota**
Os administradores podem restringir o acesso do usuário às conexões criadas no JupyterLab aplicativo configurando o [controle de acesso baseado em tags na função de](sagemaker-sql-extension-datasources-connection-permissions.md#user-defined-connections-permissions) execução.
1. Consulte [Criar segredos no Secrets Manager para credenciais de acesso de banco de dados](sagemaker-sql-extension-glue-connection-secrets.md) para verificar as propriedades e instruções de conexão para criar um segredo para sua fonte de dados.
1. Crie sua conexão na JupyterLab interface do usuário usando as instruções em[Crie conexões definidas pelo usuário AWS Glue](sagemaker-sql-extension-datasources-glue-connection-user-defined.md).
+ Se você é cientista de dados e deseja navegar e consultar suas fontes de dados usando a extensão de SQL, primeiro você ou o administrador deve configurar as conexões com suas fontes de dados. Depois, siga estas etapas:
1. Crie um espaço privado para iniciar seu JupyterLab aplicativo no Studio usando a imagem SageMaker de distribuição versão 1.6 ou superior.
1. Se você for um usuário da imagem de SageMaker distribuição versão 1.6, carregue a extensão SQL em um JupyterLab notebook executando `%load_ext amazon_sagemaker_sql_magic` em uma célula do notebook.
Para usuários das versões 1.7 e posteriores da imagem de SageMaker distribuição, nenhuma ação é necessária, a extensão SQL carrega automaticamente.
1. Familiarize-se com os recursos da extensão de SQL em [Atributos e uso da extensão SQL](sagemaker-sql-extension-features.md).
**Topics**
+ [Início rápido: consultar dados no Amazon S3](studio-sqlexplorer-athena-s3-quickstart.md)
+ [Atributos e uso da extensão SQL](sagemaker-sql-extension-features.md)
+ [Configurar o acesso à rede entre o Studio e as fontes de dados (para administradores)](sagemaker-sql-extension-networking.md)
+ [Conexões de fonte de dados da extensão de SQL](sagemaker-sql-extension-datasources-connection.md)
+ [Perguntas frequentes](sagemaker-sql-extension-faqs.md)
+ [Parâmetros de conexão](sagemaker-sql-extension-connection-properties.md)
# Início rápido: consultar dados no Amazon S3
Os usuários podem analisar dados armazenados no Amazon S3 executando consultas SQL a partir de JupyterLab notebooks usando a extensão SQL. A extensão se integra ao Athena, permitindo a funcionalidade de dados no Amazon S3 com algumas etapas extras.
Esta seção mostra as etapas para carregar dados do Amazon S3 no Athena e, em seguida, consultar esses dados JupyterLab usando a extensão SQL. Você criará uma fonte de dados e um AWS Glue rastreador do Athena para indexar seus dados do Amazon S3, configurar as permissões apropriadas do IAM para permitir o acesso ao Athena e se conectar JupyterLab ao Athena para consultar os dados. JupyterLab Seguindo essas poucas etapas, você poderá analisar os dados do Amazon S3 usando a extensão SQL em JupyterLab notebooks.
**Pré-requisitos**
Faça login no AWS Management Console usando uma conta de usuário AWS Identity and Access Management (IAM) com permissões de administrador. Para obter informações sobre como se inscrever em uma conta da AWS e criar um usuário com acesso administrativo, consulte [Pré-requisitos completos do Amazon SageMaker AI](gs-set-up.md).
Tenha um domínio de SageMaker IA e um perfil de usuário para acessar o SageMaker Studio. Para obter informações sobre como configurar um ambiente de SageMaker IA, consulte[Use a configuração rápida para Amazon SageMaker AI](onboard-quick-start.md).
Tenha um bucket e uma pasta do Amazon S3 para armazenar os resultados da consulta do Athena, usando a mesma AWS região e conta do seu ambiente de IA. SageMaker Para obter mais informações sobre como criar um bucket no Amazon S3, consulte [Criar um bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html), na documentação do Amazon S3. Você configurará o bucket e a pasta para serem o local de saída da consulta.
**Topics**
+ [Etapa 1: configurar uma fonte de dados e um AWS Glue rastreador Athena para seus dados do Amazon S3](#studio-sqlexplorer-athena-s3-quickstart-setup)
+ [Etapa 2: conceda ao Studio as permissões para acessar o Athena](#studio-sqlexplorer-athena-s3-quickstart-permissions)
+ [Etapa 3: Ativar a conexão padrão do Athena no JupyterLab](#studio-sqlexplorer-athena-s3-quickstart-connect)
+ [Etapa 4: consultar dados no Amazon S3 a partir de JupyterLab notebooks usando a extensão SQL](#studio-sqlexplorer-athena-s3-quickstart-query)
## Etapa 1: configurar uma fonte de dados e um AWS Glue rastreador Athena para seus dados do Amazon S3
Siga estas etapas para indexar seus dados no Amazon S3 e criar tabelas no Athena.
**nota**
Para evitar conflitos entre nomes de tabelas de diferentes locais do Amazon S3, crie uma fonte de dados e um crawler separados para cada local. Cada fonte de dados cria uma tabela com o nome da pasta que as contém, a menos que seja prefixada.
1. Configure um local para resultados de consultas
1. Vá para o console Athena:. [https://console.aws.amazon.com/athena/](https://console.aws.amazon.com/athena/home)
1. No menu à esquerda, escolha **Grupos de trabalho**.
1. Acesse o link do grupo de trabalho `primary` e escolha **Editar**.
1. Na seção **Configuração do resultado da consulta**, insira o caminho do Amazon S3 para seu diretório de saída e escolha **Salvar alterações**.
1. Crie uma fonte de dados do Athena para os dados do Amazon S3
1. No menu à esquerda no console do Athena, escolha **Fontes de dados** e, em seguida, **Criar fonte de dados**.
1. Escolha **S3 - Catálogo de AWS Glue dados** e, em seguida, **Avançar**.
1. Mantenha o padrão em **Catálogo de dados do AWS Glue nessa conta**, escolha **Criar um crawler no AWS Glue** e, em seguida, selecione **Criar no AWS Glue**. Isso abre o AWS Glue console.
1. Use AWS Glue para rastrear sua fonte de dados
1. Insira um nome e uma descrição para seu novo crawler e, depois, selecione **Próximo**.
1. Em **Fontes de dados**, escolha **Adicionar uma fonte de dados**.
1. Se o bucket do Amazon Amazon S3 contendo seus dados estiver em uma AWS conta diferente do seu ambiente de SageMaker IA, escolha **Em uma conta diferente** para a **localização dos dados do S3**.
1. Insira o caminho para o conjunto de dados no Amazon S3. Por exemplo:
```
s3://dsoaws/nyc-taxi-orig-cleaned-split-parquet-per-year-multiple-files/ride-info/year=2019/
```
1. Mantenha todos os outros valores padrão e escolha **Adicionar uma fonte de dados do Amazon S3**. Você deve ver uma nova fonte de dados do Amazon S3 na tabela de fontes de dados.
1. Escolha **Próximo**.
1. Configure o perfil do IAM para o crawler acessar seus dados.
**nota**
Cada perfil tem o escopo reduzido à fonte de dados que você especifica. Ao reutilizar um perfil, edite a política JSON para adicionar qualquer novo recurso ao qual você queira conceder acesso ou criar um novo perfil para essa fonte de dados.
1. Escolha **Criar novo perfil do IAM**.
1. Insira um nome para o perfil e escolha **Avançar**.
1. Crie ou selecione um banco de dados para suas tabelas
1. Se você não tiver um banco de dados existente no Athena, escolha **Adicionar banco de dados** e, em seguida, **Criar um novo banco de dados**.
1. De volta à guia anterior de criação do crawler, em **Configuração de saída**, escolha o botão **Atualizar**. Agora, você deve ver o banco de dados recém-criado na lista.
1. Selecione seu banco de dados, adicione um prefixo opcional em **Prefixo do nome da tabela** e escolha **Avançar**.
**nota**
Referente ao exemplo anterior, em que seus dados estão localizados em `s3://dsoaws/nyc-taxi-orig-cleaned-split-parquet-per-year-multiple-files/ride-info/year=2019/`, adicionar o prefixo `taxi-ride-` criará uma tabela chamada `taxi-ride-year_2019`. Adicionar um prefixo ajuda a evitar conflitos de nomes de tabelas quando vários locais de dados têm pastas com nomes idênticos.
1. Escolha **Criar crawler**.
1. Execute seu crawler para indexar seus dados. Aguarde até que a execução do crawler atinja um status de `Completed`, o que pode levar alguns minutos.
Para garantir que uma nova tabela tenha sido criada, vá para o menu à esquerda AWS Glue e escolha **Bancos de dados** e depois **Tabelas**. Agora você deve ver uma nova tabela contendo seus dados.
## Etapa 2: conceda ao Studio as permissões para acessar o Athena
Nas etapas a seguir, você concede ao perfil de execução do seu perfil de usuário permissões para acessar o Athena.
1. Recupere o ARN do perfil de execução associado ao seu perfil de usuário
1. Acesse o console de SageMaker IA em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)e escolha **Domínios** no menu à esquerda.
1. Siga o nome do seu domínio.
1. Na lista **Perfis de usuário**, siga o nome do seu perfil de usuário.
1. Na página **Detalhes do usuário**, copie o ARN do perfil de execução.
1. Atualize a política do seu perfil de execução
1. Encontre sua AWS região e o ID da conta no canto superior direito do console de SageMaker IA. Use esses valores e o nome do seu banco de dados para atualizar os espaços reservados na política JSON a seguir em um editor de texto.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "GetS3AndDataSourcesMetadata",
"Effect": "Allow",
"Action": [
"glue:GetDatabases",
"glue:GetSchema",
"glue:GetTables",
"s3:ListBucket",
"s3:GetObject",
"s3:GetBucketLocation",
"glue:GetDatabase",
"glue:GetTable",
"glue:ListSchemas",
"glue:GetPartitions"
],
"Resource": [
"arn:aws:s3:::*",
"arn:aws:glue:us-east-1:111122223333:catalog",
"arn:aws:glue:us-east-1:111122223333:database/db-name"
]
},
{
"Sid": "ExecuteAthenaQueries",
"Effect": "Allow",
"Action": [
"athena:ListDataCatalogs",
"athena:ListDatabases",
"athena:ListTableMetadata",
"athena:StartQueryExecution",
"athena:GetQueryExecution",
"athena:RunQuery",
"athena:StartSession",
"athena:GetQueryResults",
"athena:ListWorkGroups",
"s3:ListMultipartUploadParts",
"s3:ListBucket",
"s3:GetBucketLocation",
"athena:GetDataCatalog",
"s3:AbortMultipartUpload",
"s3:GetObject",
"s3:PutObject",
"athena:GetWorkGroup"
],
"Resource": [
"arn:aws:s3:::*"
]
},
{
"Sid": "GetGlueConnectionsAndSecrets",
"Effect": "Allow",
"Action": [
"glue:GetConnections",
"glue:GetConnection"
],
"Resource": [
"*"
]
}
]
}
```
------
1. Acesse o console do IAM: [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)e escolha **Funções** no menu à esquerda.
1. Pesquise seu perfil pelo nome do perfil.
**nota**
Você pode recuperar um nome de perfil de execução a partir de nome de recurso da Amazon (ARN) dividindo o ARN em `'/'` e pegando o último elemento. Por exemplo, no exemplo a seguir de um ARN `arn:aws:iam::112233445566:role/SageMakerStudio-SQLExtension-ExecutionRole`, o nome do perfil de execução é `SageMakerStudio-SQLExtension-ExecutionRole`.
1. Acesse o link do seu perfil.
1. Na guia **Permissões**, escolha **Adicionar permissões** e, em seguida, **Criar política em linha**.
1. Escolha o formato `JSON` na seção **Editor de política**.
1. Copie a política acima e escolha **Avançar**. Certifique-se de ter substituído todos os `account-id`, `region-name` e `db-name` por seus valores.
1. Insira um nome para sua política e escolha **Criar política**.
## Etapa 3: Ativar a conexão padrão do Athena no JupyterLab
Nas etapas a seguir, você habilita um `default-athena-connection` em seu JupyterLab aplicativo. A conexão padrão do Athena permite executar consultas SQL no Athena diretamente do Athena JupyterLab, sem precisar criar uma conexão manualmente.
Para ativar a conexão padrão do Athena
1. Acesse o console de SageMaker IA em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)e escolha **Studio** no menu à esquerda. Usando seu domínio e perfil de usuário, execute o Studio.
1. Escolha o JupyterLab aplicativo.
1. Se você não criou um espaço para seu JupyterLab aplicativo, escolha **Criar um JupyterLab espaço**. Insira um nome para o espaço, mantenha o espaço como **Privado** e escolha **Criar espaço**. Administre seu espaço usando a versão mais recente da imagem do SageMaker AI Distribution.
Caso contrário, escolha **Executar espaço** no seu espaço para iniciar um JupyterLab aplicativo.
1. Ative a conexão padrão do Athena:
1. Em seu JupyterLab aplicativo, navegue até o menu **Configurações** na barra de navegação superior e abra o menu **Editor de configurações**.
1. Escolha **Data Discovery**.
1. Marque a caixa **Ativar conexão padrão do Athena**.
1. Em seu JupyterLab aplicativo, escolha o ícone da extensão SQL (![\[Purple circular icon with a clock symbol representing time or scheduling.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/sqlexplorer/sqlexplorer-icon.png)) no painel de navegação esquerdo para abrir a extensão SQL.
1. Escolha o botão **Atualizar** na parte inferior do painel de descoberta de dados. Você deve ver um `default-athena-connection` na lista de conexões.
## Etapa 4: consultar dados no Amazon S3 a partir de JupyterLab notebooks usando a extensão SQL
Você está pronto para consultar seus dados usando SQL em seus JupyterLab notebooks.
1. Abra a conexão `default-athena-connection` e depois **AWS DataCatalog**.
1. Navegue até seu banco de dados e escolha o ícone de três pontos (![\[SQL extension three dots icon.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/sqlexplorer/sqlexplorer-3dots-icon.png)) à direita. Selecione **Consultar no caderno**.
Isso preenche automaticamente uma célula do notebook JupyterLab com o comando `%%sm_sql` mágico relevante para se conectar à fonte de dados. Isso também adiciona um exemplo de instrução SQL para ajudar você a começar a consultar imediatamente.
**nota**
Certifique-se de carregar a extensão na célula superior antes de executar uma consulta SQL.
Você pode refinar ainda mais a consulta SQL usando os atributos de preenchimento automático e destaque da extensão. Consulte [Recursos do editor SQL da extensão JupyterLab SQL](sagemaker-sql-extension-features-editor.md) para obter mais informações sobre como usar o editor SQL da extensão SQL.
# Atributos e uso da extensão SQL
Esta seção detalha os vários recursos da extensão JupyterLab SQL no Studio e fornece instruções sobre como usá-los. Antes de usar a extensão SQL para acessar e consultar dados de seus JupyterLab notebooks, um administrador deve primeiro configurar a conexão com suas fontes de dados. Para obter informações sobre como os administradores podem criar conexões com fontes de dados, consulte [Conexões de fonte de dados da extensão de SQL](sagemaker-sql-extension-datasources-connection.md).
**nota**
Para usar a extensão SQL, seu JupyterLab aplicativo deve ser executado em uma imagem [de distribuição SageMaker AI](https://github.com/aws/sagemaker-distribution/blob/main/README.md) versão 1.6 ou superior. Essas SageMaker imagens têm a extensão pré-instalada.
A extensão fornece dois componentes para ajudá-lo a acessar, descobrir, consultar e analisar dados de fontes de dados pré-configuradas.
+ Use a *interface do usuário* da extensão SQL para descobrir e explorar suas fontes de dados. Os atributos da interface de usuário podem ser divididos ainda mais nas seguintes categorias:
+ Com o elemento de UI de **exploração de dados**, você pode procurar suas fontes de dados e explorar suas tabelas, colunas e metadados. Para obter detalhes sobre os atributos de exploração de dados da extensão SQL, consulte [Navegue pelos dados usando a extensão SQL](sagemaker-sql-extension-features-data-discovery.md).
+ O elemento de **cache de conexão** armazena as conexões em cache para acesso rápido. Para obter detalhes sobre o cache de conexão na extensão SQL, consulte [Cache de conexão da extensão de SQL](sagemaker-sql-extension-features-connection-caching.md).
+ Use o *editor e executor de SQL* para escrever, editar e executar consultas SQL em fontes de dados conectadas.
+ Com o elemento **editor SQL**, você pode escrever, formatar e validar instruções SQL nos notebooks do seu JupyterLab aplicativo no Studio. Para obter detalhes sobre os atributos do editor de SQL, consulte [Recursos do editor SQL da extensão JupyterLab SQL](sagemaker-sql-extension-features-editor.md).
+ Com o elemento de **execução SQL**, você pode executar suas consultas SQL e visualizar seus resultados nos notebooks do seu JupyterLab aplicativo no Studio. Para obter detalhes sobre os recursos de execução de SQL, consulte [Recursos de execução de JupyterLab SQL da extensão SQL](sagemaker-sql-extension-features-sql-execution.md).
# Navegue pelos dados usando a extensão SQL
Para abrir a interface de usuário (UI) da extensão SQL, escolha o ícone da extensão SQL (![\[Purple circular icon with a clock symbol representing time or scheduling.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/sqlexplorer/sqlexplorer-icon.png)) no painel de navegação do seu JupyterLab aplicativo no Studio. A visualização de descoberta de dados do painel esquerdo se expande e exibe todas as conexões pré-configuradas do armazenamento de dados com o Amazon Athena, o Amazon Redshift e o Snowflake.
A partir daí, você pode:
+ Expandir uma conexão específica para explorar seus bancos de dados, esquemas, tabelas ou visualizações e colunas.
+ Pesquisar uma conexão específica usando a caixa de pesquisa na interface de usuário da extensão SQL. A pesquisa retorna quaisquer bancos de dados, esquemas, tabelas ou visualizações que correspondam parcialmente à sequência de caracteres inserida.
**nota**
Se o Athena já estiver configurado em sua AWS conta, você poderá habilitar um `default-athena-connection` em seu JupyterLab aplicativo. Isso permite que você execute consultas do Athena sem precisar criar a conexão manualmente. Para ativar a conexão padrão do Athena:
Verifique com seu administrador se sua função de execução tem as permissões necessárias para acessar o Athena e o AWS Glue catálogo. Para obter detalhes sobre as permissões necessárias, consulte [Configurar uma AWS Glue conexão para Athena](sagemaker-sql-extension-datasources-glue-connection.md#sagemaker-sql-extension-athena-glue-connection-config).
Em seu JupyterLab aplicativo, navegue até o menu **Configurações** na barra de navegação superior e abra o menu **Editor de configurações**.
Escolha **Data Discovery**.
Marque a caixa **Ativar conexão padrão do Athena**.
Você pode atualizar o padrão, `primary` WorkGroup se necessário.
Para consultar um banco de dados, esquema ou tabela em um JupyterLab notebook, a partir de uma determinada conexão no painel de extensão SQL:
+ Escolha o ícone de três pontos (![\[SQL extension three dots icon.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/sqlexplorer/sqlexplorer-3dots-icon.png)) no lado direito de qualquer banco de dados, esquema ou tabela.
+ Selecione **Consultar no caderno** no menu.
Isso preenche automaticamente uma célula do notebook JupyterLab com o comando `%%sm_sql` mágico relevante para se conectar à fonte de dados. Isso também adiciona um exemplo de instrução SQL para ajudar você a começar a consultar imediatamente. Você pode refinar ainda mais a consulta SQL usando os atributos de preenchimento automático e destaque da extensão. Consulte [Recursos do editor SQL da extensão JupyterLab SQL](sagemaker-sql-extension-features-editor.md) para obter mais informações sobre como usar o editor SQL da extensão SQL.
No nível da tabela, o ícone de três pontos fornece a opção adicional de escolher **pré-visualizar** os metadados de uma tabela.
O conteúdo da célula do JupyterLab notebook abaixo mostra um exemplo do que é gerado automaticamente ao selecionar o menu **Consultar no notebook** em uma fonte de `redshift-connection` dados no painel de extensão SQL.
```
%%sm_sql --metastore-id redshift-connection --metastore-type GLUE_CONNECTION
-- Query to list tables from schema 'dev.public'
SHOW TABLES
FROM
SCHEMA "dev"."public"
```
Use o símbolo de *menor que* (![\[Icon to clear the SQL extension search box.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/sqlexplorer/sqlexplorer-search-clear.png)) na parte superior do painel da extensão SQL para limpar a caixa de pesquisa ou retornar à lista de suas conexões.
**nota**
A extensão armazena em cache os resultados da exploração para acesso rápido. Se os resultados em cache estiverem desatualizados ou se uma conexão estiver faltando na lista, você poderá atualizar manualmente o cache escolhendo o botão **Atualizar** na parte inferior do painel da extensão SQL. Para ter mais informações sobre o cache de conexão, consulte [Cache de conexão da extensão de SQL](sagemaker-sql-extension-features-connection-caching.md).
# Recursos do editor SQL da extensão JupyterLab SQL
A extensão SQL fornece comandos mágicos que habilitam as funcionalidades do editor SQL nas células do seu JupyterLab notebook.
Se você for usuário da imagem de SageMaker distribuição versão 1.6, deverá carregar a biblioteca mágica da extensão SQL executando `%load_ext amazon_sagemaker_sql_magic` em um JupyterLab notebook. Isso ativa os atributos de edição do SQL.
Para usuários das versões 1.7 e posteriores da imagem de SageMaker distribuição, nenhuma ação é necessária, a extensão SQL carrega automaticamente.
Depois que a extensão for carregada, adicione o comando mágico `%%sm_sql` no início de uma célula para ativar os seguintes recursos do editor de SQL:
+ **Lista suspensa de seleção de conexão**: ao adicionar o comando mágico `%%sm_sql` mágico a uma célula, um menu suspenso aparece na parte superior da célula com suas conexões de fonte de dados disponíveis. Selecione uma conexão para preencher automaticamente os parâmetros necessários para consultar essa fonte de dados. Veja a seguir um exemplo de uma cadeia de comando mágico `%%sm_sql` gerada pela seleção da conexão chamada `connection-name`.
```
%%sm_sql --metastore-type GLUE_CONNECTION --metastore-id connection-name
```
Use os atributos do editor de SQL abaixo para criar suas consultas SQL e, em seguida, realizar a consulta executando a célula. Para obter mais informações sobre os atributos de execução do SQL, consulte [Recursos de execução de JupyterLab SQL da extensão SQL](sagemaker-sql-extension-features-sql-execution.md).
+ **Lista suspensa de resultados da consulta**: você pode especificar como renderizar os resultados da consulta selecionando um tipo de resultado no menu suspenso ao lado do menu suspenso de seleção de conexão. Escolha entre as duas alternativas a seguir:
+ **Saída da célula** (padrão): essa opção exibe o resultado da sua consulta na área de saída da célula do caderno.
+ **Pandas Dataframe**: Essa opção preenche um pandas DataFrame com os resultados da consulta. Uma caixa de entrada extra permite que você nomeie o DataFrame quando você escolhe essa opção.
+ **Destaque da sintaxe do SQL**: a célula distingue visualmente palavras-chave, cláusulas, operadores e muito mais do SQL por cor e estilo. Isso torna o código SQL mais fácil de ler e entender. Palavras-chave como `SELECT`, `FROM` e `WHERE`, e funções integradas, como `SUM` e `COUNT`, ou cláusulas como `GROUP BY` e mais, são destacadas em uma cor diferente e negrito.
+ **Formatação SQL**: você pode aplicar recuos, capitalização, espaçamento e quebras de linha consistentes para agrupar ou separar instruções e cláusulas SQL de uma das seguintes maneiras. Isso torna o código SQL mais fácil de ler e entender.
+ Clique com o botão direito do mouse na célula SQL e escolha **Formatar SQL**.
+ Quando a célula SQL estiver em foco, use o atalho *ALT \$1 F* no Windows ou *Option \$1 F* no MacOS.
+ **Preenchimento automático de SQL**: a extensão fornece sugestões automáticas e preenchimento de palavras-chave SQL, funções, nomes de tabelas, nomes de colunas e muito mais à medida que você digita. Quando você começa a digitar uma palavra-chave SQL, como `SELECT` ou `WHERE`, a extensão exibe um pop-up com sugestões para preencher automaticamente o resto da palavra. Por exemplo, ao digitar nomes de tabelas ou colunas, ela sugere nomes de tabela e coluna correspondentes definidos no esquema do banco de dados.
**Importante**
Para ativar o preenchimento automático de SQL em JupyterLab notebooks, os usuários da imagem de distribuição SageMaker AI versão 1.6 devem executar o seguinte `npm install -g vscode-jsonrpc sql-language-server` comando em um terminal. Depois que a instalação for concluída, reinicie o JupyterLab servidor executando`restart-jupyter-server`.
Para usuários das versões 1.7 e posteriores de imagens de SageMaker distribuição, nenhuma ação é necessária.
A célula oferece dois métodos para preencher automaticamente palavras-chave SQL reconhecidas:
+ Invocação explícita (recomendada): escolha a tecla **Tab** para iniciar o menu de sugestão contextual e, em seguida, escolha **Enter** para aceitar o item sugerido.
+ Dicas contínuas: a célula sugere automaticamente as conclusões à medida que você digita.
**nota**
O preenchimento automático só é acionado se as palavras-chave SQL estiverem em maiúsculas. Por exemplo, inserir prompts `SEL` para `SELECT`, porque digitar `sel` não funciona.
Na primeira vez que você se conecta a uma fonte de dados, o preenchimento automático de SQL indexa os metadados da fonte de dados. Esse processo de indexação pode levar algum tempo para ser concluído, dependendo do tamanho dos seus bancos de dados.
# Recursos de execução de JupyterLab SQL da extensão SQL
Você pode executar consultas SQL em suas fontes de dados conectadas na extensão SQL do JupyterLab. As seções a seguir explicam os parâmetros mais comuns para executar consultas SQL em JupyterLab notebooks:
+ Crie uma conexão simples em [Crie uma cadeia de conexão de comando mágico simples](sagemaker-sql-extension-features-sql-execution-create-connection.md).
+ Salve os resultados da consulta em um pandas DataFrame em[Salve os resultados da consulta SQL em um pandas DataFrame](sagemaker-sql-extension-features-sql-execution-save-dataframe.md).
+ Substitua ou adicione às propriedades de conexão definidas pelo administrador em [Substituir propriedades de conexão](sagemaker-sql-extension-features-sql-execution-override-connection.md).
+ [Use parâmetros de consulta para fornecer valores dinâmicos em consultas SQL](sagemaker-sql-extension-features-sql-execution-query-parameters.md).
Quando você executa uma célula com o comando mágico `%%sm_sql`, o mecanismo de extensão de SQL executa a consulta SQL na célula em relação à fonte de dados especificada nos parâmetros do comando mágico.
Para ver os detalhes dos parâmetros do comando mágico e dos formatos compatíveis, execute `%%sm_sql?`.
**Importante**
Para usar o Snowflake, os usuários da imagem de SageMaker distribuição versão 1.6 devem instalar a dependência do Python do Snowflake executando o comando a `micromamba install snowflake-connector-python -c conda-forge` seguir em um terminal do aplicativo. JupyterLab Reinicie o JupyterLab servidor executando `restart-jupyter-server` no terminal após a conclusão da instalação.
Para imagens SageMaker de distribuição nas versões 1.7 e posteriores, a dependência do Snowflake está pré-instalada. Nenhuma ação é necessária.
# Crie uma cadeia de conexão de comando mágico simples
Se o administrador configurou as conexões com suas fontes de dados, siga estas etapas para criar facilmente uma cadeia de conexão em uma célula do caderno:
1. Abra uma célula do caderno que usa `%%sm_sql`.
1. Selecione uma conexão pré-configurada com a fonte de dados desejada no menu suspenso de conexão acima da célula.
1. Isso preencherá automaticamente os parâmetros necessários para consultar essa fonte de dados.
Como alternativa, você pode especificar propriedades de conexão em linha na célula.
A escolha de uma conexão no menu suspenso insere os dois parâmetros a seguir na cadeia de comando mágico padrão. Os parâmetros contêm as informações de conexão que seu administrador configurou.
+ `--metastore-id`: o nome do objeto de conexão que contém seus parâmetros de conexão.
+ `--metastore-type`: o tipo de meta-armazenamento correspondente a `--metastore-id`. A extensão SQL usa AWS Glue conexões como um meta-armazenamento de conexões. Esse número é automaticamente definido como `GLUE_CONNECTION`.
Por exemplo, a cadeia de conexão para um armazenamento de dados pré-configurado do Amazon Athena tem a seguinte aparência:
```
%%sm_sql --metastore-id athena-connection-name --metastore-type GLUE_CONNECTION
```
# Salve os resultados da consulta SQL em um pandas DataFrame
Você pode armazenar os resultados da sua consulta SQL em um pandas DataFrame. **A maneira mais fácil de enviar os resultados da consulta para a DataFrame é usar o menu suspenso [Recursos do editor SQL da extensão JupyterLab SQL](sagemaker-sql-extension-features-editor.md) de resultados da consulta e escolher a opção Pandas dataframe.**
Como alternativa, você pode adicionar o parâmetro `--output '{"format": "DATAFRAME", "dataframe_name": "dataframe_name"}'` à sua cadeia de conexão.
Por exemplo, a consulta a seguir extrai detalhes dos clientes com o maior saldo da tabela `Customer` no banco de dados `TPCH_SF1` do Snowflake, usando pandas e SQL:
+ Neste exemplo, extraímos todos os dados da tabela de clientes e os salvamos em um DataFrame nome`all_customer_data`.
```
%%sm_sql --output '{"format": "DATAFRAME", "dataframe_name": "all_customer_data"}' --metastore-id snowflake-connection-name --metastore-type GLUE_CONNECTION
SELECT * FROM SNOWFLAKE_SAMPLE_DATA.TPCH_SF1.CUSTOMER
```
```
Saved results to all_customer_data
```
+ Em seguida, extraímos os detalhes do maior saldo da conta do DataFrame.
```
all_customer_data.loc[all_customer_data['C_ACCTBAL'].idxmax()].values
```
```
array([61453, 'Customer#000061453', 'RxNgWcyl5RZD4qOYnyT3', 15,
'25-819-925-1077', Decimal('9999.99'), 'BUILDING','es. carefully regular requests among the blithely pending requests boost slyly alo'],
dtype=object)
```
# Substituir propriedades de conexão
As definições de conexão predefinidas do administrador podem não ter os parâmetros exatos de que você precisa para se conectar a um armazenamento de dados específico. Você pode adicionar ou substituir parâmetros na cadeia de conexão usando o argumento `--connection-properties`.
Os argumentos são aplicados na seguinte ordem de precedência:
1. Propriedades de conexão substituídas fornecidas como argumentos embutidos.
1. Propriedades de conexão presentes no AWS Secrets Manager.
1. Propriedades da conexão na AWS Glue conexão.
Se a mesma propriedade de conexão estiver presente em todos os três (argumento da linha de comando, Secrets Manager e conexão), o valor fornecido no argumento da linha de comando prevalece.
Para obter mais informações sobre as propriedades de conexão disponíveis por fonte de dados, consulte [Parâmetros de conexão](sagemaker-sql-extension-connection-properties.md).
O exemplo a seguir ilustra um argumento de propriedade de conexão que define o nome do esquema para o Amazon Athena.
```
%%sm_sql --connection-properties '{"schema_name": "athena-db-name"}' --metastore-id athena-connection-name --metastore-type GLUE_CONNECTION
```
# Use parâmetros de consulta para fornecer valores dinâmicos em consultas SQL
Os parâmetros de consulta podem ser usados para fornecer valores dinâmicos em consultas SQL.
No seguinte exemplo, passamos um parâmetro de consulta para a cláusula `WHERE` da consulta:
```
# How to use '--query-parameters' with ATHENA as a data store
%%sm_sql --metastore-id athena-connection-name --metastore-type GLUE_CONNECTION --query-parameters '{"parameters":{"name_var": "John Smith"}}'
SELECT * FROM my_db.my_schema.my_table WHERE name = (%(name_var)s);
```
# Cache de conexão da extensão de SQL
A extensão de SQL usa como padrão o armazenamento em cache de conexões para impedir a criação de várias conexões para o mesmo conjunto de propriedades de conexão. As conexões em cache podem ser gerenciadas usando o comando mágico `%sm_sql_manage`.
Os tópicos a seguir descrevem como gerenciar suas conexões em cache.
**Topics**
+ [Criar conexões em cache](sagemaker-sql-extension-features-create-cached-connection.md)
+ [Listar conexões em cache](sagemaker-sql-extension-features-list-cached-connection.md)
+ [Limpar conexões em cache](sagemaker-sql-extension-features-clear-cached-connection.md)
+ [Desabilitar conexões em cache](sagemaker-sql-extension-features-disable-cached-connection.md)
# Criar conexões em cache
Você pode criar conexões em cache especificando um nome de conexão no parâmetro `--connection-name` da sua cadeia de conexão. Isso é particularmente útil quando várias propriedades de conexão são substituídas para um caso de uso específico e é necessário reutilizar as mesmas propriedades sem digitá-las novamente.
Por exemplo, o código abaixo salva uma conexão do Athena com uma propriedade de conexão de esquema substituída usando o nome `--connection-name my_athena_conn_with_schema` e a reutiliza em outra célula:
```
%%sm_sql --connection-name my_athena_conn_with_schema --connection-properties '{"schema_name": "sm-sql-private-beta-db"}' --metastore-id sm-sql-private-beta-athena-connection --metastore-type GLUE_CONNECTION
SELECT * FROM "covid_table" LIMIT 2
```
```
%%sm_sql --connection-name my_athena_conn_with_schema
SELECT * FROM "covid_table" LIMIT 2
```
# Listar conexões em cache
Você pode listar suas conexões em cache executando o seguinte comando:
```
%sm_sql_manage --list-cached-connections
```
# Limpar conexões em cache
Para limpar todas as conexões em cache, execute o seguinte comando:
```
%sm_sql_manage --clear-cached-connections
```
# Desabilitar conexões em cache
Para desabilitar o armazenamento em cache de conexões, use o seguinte comando:
```
%sm_sql_manage --set-connection-reuse False
```
# Configurar o acesso à rede entre o Studio e as fontes de dados (para administradores)
Esta seção fornece informações sobre como os administradores podem configurar uma rede para permitir a comunicação entre o Amazon SageMaker Studio e o Amazon Redshift ou o [Amazon](https://aws.amazon.com/redshift/) [Athena](https://aws.amazon.com/athena/), seja dentro de uma Amazon VPC privada ou pela Internet. As instruções de rede variam de acordo com o fato de o domínio do Studio e o armazenamento de dados estarem implantados em uma [nuvem privada virtual (VPC) da Amazon](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html) ou se comunicarem pela internet.
Por padrão, o Studio é executado em uma VPC AWS gerenciada com [acesso à Internet](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-notebooks-and-internet-access.html#studio-notebooks-and-internet-access-default). Ao usar uma conexão com a Internet, o Studio acessa AWS recursos, como buckets do Amazon S3, pela Internet. No entanto, se você tiver requisitos de segurança para controlar o acesso aos contêineres de dados e tarefas, recomendamos que você configure o Studio e o armazenamento de dados (Amazon Redshift ou Athena) para que seus dados e contêineres não sejam acessíveis pela internet. Para controlar o acesso aos seus recursos ou executar o Studio sem acesso público à Internet, você pode especificar o tipo de acesso à `VPC only` rede ao fazer a integração com o [domínio Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/gs-studio-onboard.html). Nesse cenário, o Studio estabelece conexões com outros serviços AWS por meio de [endpoints privados da VPC](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html). Para obter informações sobre como configurar o Studio no modo `VPC only`, consulte [Conectar o Studio a recursos externos em uma VPC](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-notebooks-and-internet-access.html#studio-notebooks-and-internet-access-vpc-only).
**nota**
Para se conectar ao Snowflake, a VPC do domínio do Studio deve ter acesso à internet.
As duas primeiras seções descrevem como garantir a comunicação entre seu domínio do Studio e seu armazenamento de dados VPCs sem acesso público à Internet. A última seção aborda como garantir a comunicação entre o Studio e o seu armazenamento de dados usando uma conexão com a internet. Antes de conectar o Studio e seu armazenamento de dados sem acesso à Internet, certifique-se de estabelecer endpoints para o Amazon Simple Storage Service, Amazon Redshift ou Athena SageMaker , AI, e para a CloudWatch Amazon e (registro AWS CloudTrail e monitoramento).
+ Se o Studio e o armazenamento de dados estiverem em locais diferentes VPCs, na mesma AWS conta ou em contas separadas, consulte[O Studio e o armazenamento de dados são implantados separadamente VPCs](#sagemaker-sql-extension-networking-cross-vpc).
+ Se o Studio e o armazenamento de dados estiverem na mesma VPC, consulte [O Studio e o armazenamento de dados são implantados na mesma VPC](#sagemaker-sql-extension-networking-same-vpc).
+ Se você optar por conectar o Studio e o armazenamento de dados pela internet pública, consulte [O Studio e o armazenamento de dados se comunicam pela internet pública](#sagemaker-sql-extension-networking-internet).
## O Studio e o armazenamento de dados são implantados separadamente VPCs
Para permitir a comunicação entre o Studio e um armazenamento de dados implantado em diferentes VPCs:
1. Comece conectando seu por VPCs meio de uma conexão de emparelhamento VPC.
1. Atualize as tabelas de roteamento em cada VPC para permitir o tráfego de rede bidirecional entre as sub-redes do Studio e as sub-redes do armazenamento de dados.
1. Configure seus grupos de segurança da VPC para permitir tráfego de entrada e saída.
As etapas de configuração são as mesmas, independentemente de o Studio e o armazenamento de dados serem implantados em uma única AWS conta ou em AWS contas diferentes.
1.
**emparelhamento da VPC**
Crie uma [conexão de emparelhamento VPC](https://docs.aws.amazon.com/vpc/latest/peering/working-with-vpc-peering.html) para facilitar a rede entre os dois VPCs (Studio e o armazenamento de dados).
1. Na sua conta do Studio, no painel da VPC, escolha **Conexões de emparelhamento** e, em seguida, **Criar conexão de emparelhamento**.
1. Crie sua solicitação para emparelhar a VPC do Studio com a VPC do armazenamento de dados. Ao solicitar o emparelhamento em outra AWS conta, escolha **Outra conta** em **Selecionar outra VPC para fazer** o peering.
Para emparelhamento entre contas cruzadas, o administrador deve aceitar a solicitação da conta solicitante.
Ao emparelhar sub-redes privadas, você deve ativar a resolução de DNS de IP privado na conexão de emparelhamento de VPC.
1.
**Tabelas de rotas**
Configure o roteamento para permitir o tráfego de rede entre o Studio as sub-redes de VPC do armazenamento de dados em ambas as direções.
Depois de estabelecer a conexão de emparelhamento, o administrador (em cada conta para acesso entre contas) pode adicionar rotas às tabelas de rotas da sub-rede privada para rotear o tráfego entre o Studio e as sub-redes do armazenamento de dados VPCs. Você pode definir essas rotas acessando a seção **Tabelas de rotas** de cada VPC no painel da VPC.
1.
**Grupos de segurança**
Por fim, o grupo de segurança da VPC de domínio do Studio deve permitir tráfego de saída, e o grupo de segurança da VPC do armazenamento de dados deve permitir tráfego de entrada na porta do seu armazenamento de dados a partir do grupo de segurança da VPC do Studio.
## O Studio e o armazenamento de dados são implantados na mesma VPC
Se o Studio e o armazenamento de dados estiverem em sub-redes privadas diferentes na mesma VPC, adicione rotas na tabela de rotas de cada sub-rede privada. As rotas devem permitir que o tráfego flua entre as sub-redes do Studio e as sub-redes do armazenamento de dados. Você pode definir essas rotas acessando a seção **Tabelas de rotas** de cada VPC no painel da VPC. Se você implantou o Studio e o armazenamento de dados na mesma VPC e na mesma sub-rede, não precisa rotear o tráfego.
Independentemente de qualquer atualização da tabela de roteamento, o grupo de segurança da VPC de domínio do Studio deve permitir tráfego de saída, e o grupo de segurança da VPC do armazenamento de dados deve permitir tráfego de entrada em sua porta a partir do grupo de segurança da VPC do Studio.
## O Studio e o armazenamento de dados se comunicam pela internet pública
Por padrão, o Studio fornece uma interface de rede que permite a comunicação com a internet por meio de um gateway da internet na VPC associada ao domínio do Studio. Se você optar por se conectar ao seu armazenamento de dados pela internet pública, seu armazenamento de dados precisará aceitar tráfego de entrada em sua porta.
Um [gateway NAT](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-working-with) deve ser usado para permitir que instâncias em sub-redes privadas de várias VPCs compartilhem um único endereço IP público fornecido pelo [gateway da Internet](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Internet_Gateway.html) ao acessar a Internet.
**nota**
Cada porta aberta para tráfego de entrada representa um risco potencial de segurança. Revise atentamente os grupos de segurança personalizados para minimizar vulnerabilidades.
# Conexões de fonte de dados da extensão de SQL
Antes de usar a extensão SQL em JupyterLab notebooks, administradores ou usuários devem criar AWS Glue conexões com suas fontes de dados. A extensão de SQL permite a conexão com fontes de dados, como o Amazon Redshift, Amazon Athena ou Snowflake.
Para configurar as conexões, os administradores devem primeiro garantir que a configuração de rede permita a comunicação entre o Studio e as fontes de dados e, em seguida, conceder as permissões necessárias do IAM para que o Studio acesse as fontes de dados. Para ter informações sobre como os administradores podem configurar a rede, consulte [Configurar o acesso à rede entre o Studio e as fontes de dados (para administradores)](sagemaker-sql-extension-networking.md). Para ter informações sobre quais políticas devem ser configuradas, consulte [Configurar as permissões do IAM para acessar as fontes de dados (para administradores)](sagemaker-sql-extension-datasources-connection-permissions.md). Depois que as conexões são configuradas, os cientistas de dados podem usar a extensão SQL em seus JupyterLab notebooks para navegar e consultar as fontes de dados conectadas.
**nota**
Recomendamos armazenar suas credenciais de acesso ao banco de dados como um segredo no Secrets Manager. Para saber como criar segredos para armazenar as credenciais de acesso do Amazon Redshift ou do Snowflake, consulte [Criar segredos no Secrets Manager para credenciais de acesso de banco de dados](sagemaker-sql-extension-glue-connection-secrets.md).
Esta seção explica como configurar uma AWS Glue conexão e lista as permissões do IAM necessárias para que o JupyterLab aplicativo Studio acesse os dados por meio da conexão.
**nota**
[O Amazon SageMaker Assets](sm-assets.md) integra a [Amazon DataZone](https://docs.aws.amazon.com/datazone/latest/userguide/what-is-datazone.html) com o Studio. Ele inclui um plano de SageMaker IA para administradores criarem ambientes Studio a partir de DataZone projetos da Amazon em um domínio da Amazon DataZone .
Os usuários de um JupyterLab aplicativo lançado a partir de um domínio do Studio criado com o blueprint podem acessar automaticamente AWS Glue as conexões com ativos de dados em seu DataZone catálogo da Amazon ao usar a extensão SQL. Isso permite consultar essas fontes de dados sem configurar manualmente as conexões.
**Topics**
+ [Criar segredos no Secrets Manager para credenciais de acesso de banco de dados](sagemaker-sql-extension-glue-connection-secrets.md)
+ [Crie AWS Glue conexões (para administradores)](sagemaker-sql-extension-datasources-glue-connection.md)
+ [Crie conexões definidas pelo usuário AWS Glue](sagemaker-sql-extension-datasources-glue-connection-user-defined.md)
+ [Configurar as permissões do IAM para acessar as fontes de dados (para administradores)](sagemaker-sql-extension-datasources-connection-permissions.md)
# Criar segredos no Secrets Manager para credenciais de acesso de banco de dados
Antes de criar sua conexão, recomendamos armazenar suas credenciais de acesso ao banco de dados como um segredo em AWS Secrets Manager. Como alternativa, você pode gerar credenciais temporárias de banco de dados com base nas permissões concedidas por meio de uma política de permissões AWS Identity and Access Management (IAM) para gerenciar o acesso que seus usuários têm ao seu banco de dados. Para ter mais informações, consulte [Usar a autenticação do IAM para gerar credenciais do usuário do banco de dados](https://docs.aws.amazon.com/redshift/latest/mgmt/generating-user-credentials.html).
## Criar um segredo para as credenciais de acesso do Amazon Redshift
**Para armazenar informações do Amazon Redshift no AWS Secrets Manager**
1. Em Console de gerenciamento da AWS, navegue até Secrets Manager.
1. Selecione **Armazenar um novo segredo**.
1. Em **Tipo de segredo**, escolha **Credenciais para o Amazon Redshift**.
1. Insira o nome de usuário e a senha do administrador configurados ao iniciar o cluster do Amazon Redshift.
1. Selecione o cluster do Amazon Redshift associado aos segredos.
1. Dê um nome ao seu segredo.
1. As configurações restantes podem ser deixadas com seus valores padrão para a criação inicial do segredo ou personalizadas, se necessário.
1. Crie o segredo e recupere seu ARN.
## Criar um segredo para as credenciais de acesso do Amazon Redshift sem servidor
**Se você precisar se conectar ao Amazon Redshift sem servidor, siga estas etapas:**
1. Em Console de gerenciamento da AWS, navegue até Secrets Manager.
1. Selecione **Armazenar um novo segredo**.
1. Em **Tipo de segredo**, escolha **Outro tipo de segredo**.
1. Em **Pares de chaver-chave**, escolha **Texto simples** e, em seguida, copie o conteúdo JSON a seguir. Substitua o usuário e a senha pelos respectivos valores reais:
```
{
"user": "redshift_user",
"password": "redshift_password"
}
```
1. Crie o segredo e recupere o respectivo ARN.
1. Ao criar uma nova conexão na extensão SQL em JupyterLab, forneça todos os outros parâmetros de conexão do Amazon Redshift conforme necessário.
## Criar um segredo para as credenciais de acesso do Snowflake
Esta seção fornece detalhes sobre as propriedades de conexão e segredo nos arquivos de definição JSON que são específicos do Snowflake. Antes de criar sua conexão, recomendamos armazenar suas credenciais de acesso do Snowflake como um segredo no Secrets Manager.
**Para armazenar informações do Amazon Redshift no Secrets Manager**
1. Em Console de gerenciamento da AWS, navegue até Secrets Manager.
1. Selecione **Armazenar um novo segredo**.
1. Em **Tipo de segredo**, escolha **Outro tipo de segredo**.
1. No par de valor-chave, escolha **Texto simples** e, em seguida, copie o conteúdo JSON a seguir. Substitua o `user`, `password` e `account` por seus valores.
```
{
"user":"snowflake_user",
"password":"snowflake_password",
"account":"account_id"
}
```
1. Dê um nome ao segredo.
1. As configurações restantes podem ser deixadas com seus valores padrão para a criação inicial do segredo ou personalizadas, se necessário.
1. Crie o segredo e recupere seu ARN.
# Crie AWS Glue conexões (para administradores)
Para usar fontes de dados com a extensão SQL, os administradores podem configurar AWS Glue conexões para cada fonte de dados. Essas conexões armazenam os detalhes necessários da configuração para acessar e interagir com as fontes de dados. Depois que as conexões são criadas e as [permissões apropriadas](sagemaker-sql-extension-datasources-connection-permissions.md) são concedidas, as conexões se tornam visíveis para todos os usuários de [Espaços do Amazon SageMaker Studio](studio-updated-spaces.md) que compartilham o mesmo perfil de execução.
Para criar as conexões:
+ Primeiro, crie um arquivo JSON que defina as propriedades de conexão de cada fonte de dados. O arquivo JSON inclui detalhes como o identificador da fonte de dados, as credenciais de acesso e outros parâmetros de configuração relevantes para acessar as fontes de dados por meio das AWS Glue conexões.
+ Em seguida, use o AWS Command Line Interface (AWS CLI) para criar a AWS Glue conexão, passando o arquivo JSON como parâmetro. O AWS CLI comando lê os detalhes da conexão do arquivo JSON e estabelece a conexão apropriada.
**nota**
A extensão SQL é compatível com a criação de conexões usando a AWS CLI apenas.
Antes de criar AWS Glue conexões, certifique-se de concluir as seguintes etapas:
+ Instale e configure o AWS Command Line Interface (AWS CLI). Para obter mais informações sobre como instalar e configurar o AWS CLI, consulte [Sobre a AWS CLI versão 2](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html). Certifique-se de que as chaves de acesso e os tokens do usuário ou da função do IAM usados para configurá-los AWS CLI tenham as permissões necessárias para criar AWS Glue conexões. Adicione uma política que permita a ação `glue:CreateConnection`.
+ Entenda como usar AWS Secrets Manager. Recomendamos usar o Secrets Manager para fornecer credenciais de conexão e qualquer outra informação confidencial para seu armazenamento de dados. Para obter mais informações sobre como usar o Secrets Manager para armazenar credenciais, consulte [Armazenando credenciais de conexão no AWS Secrets](https://docs.aws.amazon.com/glue/latest/dg/connection-properties-secrets-manager.html) Manager.
## Criar um arquivo JSON de definição de conexão
Para criar um arquivo de definição de AWS Glue conexão, crie um arquivo JSON para definir os detalhes da conexão na máquina em que você instalou e configurou o. AWS CLI Neste exemplo, o nome do arquivo é `sagemaker-sql-connection.json`.
O arquivo de definição de conexão deve seguir o seguinte formato geral:
+ **Nome** é o nome da conexão.
+ **Descrição** é uma descrição textual da conexão.
+ **ConnectionType**é o tipo de conexão. Escolha `REDSHIFT`, `ATHENA` ou `SNOWFLAKE`.
+ **ConnectionProperties**é um mapa de pares de valores-chave para as propriedades da conexão, como o ARN do seu AWS segredo ou o nome do seu banco de dados.
```
{
"ConnectionInput": {
"Name": ,
"Description": ,
"ConnectionType": "REDSHIFT | ATHENA | SNOWFLAKE",
"ConnectionProperties": {
"PythonProperties": "{\"aws_secret_arn\": , \"database\": <...>}"
}
}
}
```
**nota**
As propriedades dentro da chave `ConnectionProperties` consistem em pares de valores-chave em forma de string. Evite as aspas duplas usadas nas chaves ou valores com um caractere de barra invertida (`\`).
Todas as propriedades disponíveis no Secrets Manager também podem ser fornecidas diretamente pelo `PythonProperties`. No entanto, não é recomendável incluir campos confidenciais, como senhas em `PythonProperties`. Em vez disso, a abordagem recomendada é usar o Secrets Manager.
Arquivos de definição de conexão específicos para armazenamentos de dados diferentes podem ser encontrados nas seções a seguir.
Os arquivos de definição de conexão de cada fonte de dados contêm as propriedades e a configuração específicas necessárias para fazer a conexão com esses armazenamentos de dados a partir da extensão de SQL. Consulte a seção apropriada para obter detalhes sobre como definir conexões com essa fonte.
+ Para criar uma AWS Glue conexão para o Amazon Redshift, consulte o arquivo de definição de amostra em. [Configurar uma AWS Glue conexão para o Amazon Redshift](#sagemaker-sql-extension-redshift-glue-connection-config)
+ Para criar uma AWS Glue conexão para o Amazon Athena, consulte o arquivo de definição de amostra em. [Configurar uma AWS Glue conexão para Athena](#sagemaker-sql-extension-athena-glue-connection-config)
+ Para criar uma AWS Glue conexão para o Snowflake, consulte o arquivo de definição de amostra em. [Configurar uma AWS Glue conexão para o Snowflake](#sagemaker-sql-extension-snowflake-glue-connection-config)
### Configurar uma AWS Glue conexão para o Amazon Redshift
Esta seção fornece detalhes sobre as propriedades de conexão e segredo nos arquivos de definição JSON que são específicos do Amazon Redshift. Antes de criar seu arquivo de configuração de conexão, recomendamos armazenar suas credenciais de acesso do Amazon Redshift como um segredo no Secrets Manager. Como alternativa, você pode gerar credenciais temporárias de banco de dados com base nas permissões concedidas por meio de uma política de permissões AWS Identity and Access Management (IAM) para gerenciar o acesso que seus usuários têm ao seu banco de dados do Amazon Redshift. Para obter mais informações, consulte [Uso da autenticação do IAM para gerar credenciais do usuário do banco de dados](https://docs.aws.amazon.com/redshift/latest/mgmt/generating-user-credentials.html).
#### Criar um segredo para as credenciais de acesso do Amazon Redshift
**Para armazenar informações do Amazon Redshift no AWS Secrets Manager**
1. No AWS console, navegue até Secrets Manager.
1. Selecione **Armazenar um novo segredo**.
1. Em **Tipo de segredo**, escolha **Credenciais para o Amazon Redshift**.
1. Insira o nome de usuário e a senha do administrador configurados ao iniciar o cluster do Amazon Redshift.
1. Selecione o cluster do Amazon Redshift associado aos segredos.
1. Dê um nome ao seu segredo.
1. As configurações restantes podem ser deixadas com seus valores padrão para a criação inicial do segredo ou personalizadas, se necessário.
1. Crie o segredo e recupere seu ARN.
#### Configurar uma AWS Glue conexão para o Amazon Redshift
A extensão SQL se conecta às fontes de dados usando AWS Glue conexões personalizadas. Para obter informações gerais sobre como criar AWS Glue conexões para conectar uma fonte de dados, consulte[Crie AWS Glue conexões (para administradores)](#sagemaker-sql-extension-datasources-glue-connection). O exemplo a seguir é um exemplo de definição de AWS Glue conexão para se conectar ao Amazon Redshift.
Antes de criar uma nova conexão, lembre-se destas recomendações:
+ As propriedades dentro da chave `PythonProperties` consistem em pares de valores-chave em forma de string. Evite as aspas duplas usadas nas chaves ou valores com um caractere de barra invertida (`\`).
+ No arquivo de definição de conexão, insira o nome e a descrição da conexão, substitua o ARN do segredo em `aws_secret_arn` pelo ARN do segredo criado anteriormente.
+ Certifique-se de que o banco de dados declarado pelo nome na definição de conexão acima corresponda ao banco de dados do cluster. Você pode verificar isso acessando a página de detalhes do cluster no [console do Amazon Redshift](https://console.aws.amazon.com/redshiftv2/) e verificando o nome do banco de dados em **Configurações do banco de dados** na seção **Propriedades**.
+ Para obter parâmetros adicionais, consulte a lista de propriedades de conexão compatíveis com o Amazon Redshift em [Parâmetros de conexão do Amazon Redshift](sagemaker-sql-extension-connection-properties.md#sagemaker-sql-extension-connection-properties-redshift).
**nota**
Por padrão, o conector de extensão SQL para Python executa todas as consultas em uma transação, a menos que `auto_commit` nas propriedades da conexão esteja definido como `true`.
Você pode adicionar todos os parâmetros de conexão, incluindo o nome `database`, a um segredo.
```
{
"ConnectionInput": {
"Name": "Redshift connection name",
"Description": "Redshift connection description",
"ConnectionType": "REDSHIFT",
"ConnectionProperties": {
"PythonProperties":"{\"aws_secret_arn\": \"arn:aws:secretsmanager:region:account_id:secret:secret_name\", \"database\":\"database_name\", \"database_metadata_current_db_only\": false}"
}
}
}
```
Depois que seu arquivo de definição for atualizado, siga as etapas [Crie AWS Glue conexões](#sagemaker-sql-extension-datasources-glue-connection-creation) para criar sua AWS Glue conexão.
### Configurar uma AWS Glue conexão para Athena
Esta seção fornece detalhes sobre as propriedades de conexão nos arquivos de definição JSON que são específicos do Athena.
#### Configurar uma AWS Glue conexão para Athena
A extensão SQL se conecta às fontes de dados usando AWS Glue conexões personalizadas. Para obter informações gerais sobre como criar AWS Glue conexões para conectar uma fonte de dados, consulte[Crie AWS Glue conexões (para administradores)](#sagemaker-sql-extension-datasources-glue-connection). O exemplo a seguir é um exemplo de definição de AWS Glue conexão para se conectar ao Athena.
Antes de criar uma nova conexão, lembre-se destas recomendações:
+ As propriedades dentro da chave `ConnectionProperties` consistem em pares de valores-chave em forma de string. Evite as aspas duplas usadas nas chaves ou valores com um caractere de barra invertida (`\`).
+ No arquivo de definição de conexão, insira o nome e a descrição da conexão, substitua o `catalog_name` pelo nome do seu catálogo, `s3_staging_dir` pelo URI do Amazon S3 (Uniform Resource Identifier) do seu diretório de saída no bucket do Amazon S3 e `region_name` pela região do bucket do Amazon S3.
+ Para obter parâmetros adicionais, consulte a lista de propriedades de conexão compatíveis com o Athena em [Parâmetros de conexão do Athena](sagemaker-sql-extension-connection-properties.md#sagemaker-sql-extension-connection-properties-athena).
**nota**
Você pode adicionar todos os parâmetros de conexão, incluindo o `catalog_name` ou `s3_staging_dir`, a um segredo.
Se você especificar um `workgroup`, você não precisa especificar `s3_staging_dir`.
```
{
"ConnectionInput": {
"Name": "Athena connection name",
"Description": "Athena connection description",
"ConnectionType": "ATHENA",
"ConnectionProperties": {
"PythonProperties": "{\"catalog_name\": \"catalog_name\",\"s3_staging_dir\": \"s3://amzn-s3-demo-bucket_in_same_region/output_query_results_dir/\", \"region_name\": \"region\"}"
}
}
}
```
Depois que seu arquivo de definição for atualizado, siga as etapas [Crie AWS Glue conexões](#sagemaker-sql-extension-datasources-glue-connection-creation) para criar sua AWS Glue conexão.
### Configurar uma AWS Glue conexão para o Snowflake
Esta seção fornece detalhes sobre as propriedades de conexão e segredo nos arquivos de definição JSON que são específicos do Snowflake. Antes de criar seu arquivo de configuração de conexão, recomendamos armazenar suas credenciais de acesso do Snowflake como um segredo no Secrets Manager.
#### Criar um segredo para as credenciais de acesso do Snowflake
**Para armazenar informações do Amazon Redshift no Secrets Manager**
1. No AWS console, navegue até AWS Secrets Manager.
1. Selecione **Armazenar um novo segredo**.
1. Em **Tipo de segredo**, escolha **Outro tipo de segredo**.
1. No par de valor-chave, escolha **Texto simples** e, em seguida, copie o conteúdo JSON a seguir. Substitua o `user`, `password` e `account` por seus valores.
```
{
"user":"snowflake_user",
"password":"snowflake_password",
"account":"account_id"
}
```
1. Dê um nome ao segredo.
1. As configurações restantes podem ser deixadas com seus valores padrão para a criação inicial do segredo ou personalizadas, se necessário.
1. Crie o segredo e recupere seu ARN.
#### Configurar uma AWS Glue conexão para o Snowflake
A extensão SQL se conecta às fontes de dados usando AWS Glue conexões personalizadas. Para obter informações gerais sobre como criar AWS Glue conexões para conectar uma fonte de dados, consulte[Crie AWS Glue conexões (para administradores)](#sagemaker-sql-extension-datasources-glue-connection). O exemplo a seguir é um exemplo de definição de AWS Glue conexão para conexão com o Snowflake.
Antes de criar uma nova conexão, lembre-se destas recomendações:
+ As propriedades dentro da chave `ConnectionProperties` consistem em pares de valores-chave em forma de string. Evite as aspas duplas usadas nas chaves ou valores com um caractere de barra invertida (`\`).
+ No arquivo de definição de conexão, insira o nome e a descrição da conexão e, em seguida, substitua o ARN do segredo em `aws_secret_arn` pelo ARN do segredo criado anteriormente e o ID da sua conta em `account`.
+ Para obter parâmetros adicionais, consulte a lista de propriedades de conexão compatíveis com o Snowflake em [Parâmetros de conexão do Snowflake](sagemaker-sql-extension-connection-properties.md#sagemaker-sql-extension-connection-properties-snowflake).
**nota**
Você pode adicionar todos os parâmetros de conexão, incluindo o `account`, a um segredo.
```
{
"ConnectionInput": {
"Name": "Snowflake connection name",
"Description": "Snowflake connection description",
"ConnectionType": "SNOWFLAKE",
"ConnectionProperties": {
"PythonProperties": "{\"aws_secret_arn\": \"arn:aws:secretsmanager:region:account_id:secret:secret_name\", \"account\":\"account_id\"}"}"
}
}
}
```
Depois que seu arquivo de definição for atualizado, siga as etapas [Crie AWS Glue conexões](#sagemaker-sql-extension-datasources-glue-connection-creation) para criar sua AWS Glue conexão.
## Crie AWS Glue conexões
Para criar uma AWS Glue conexão por meio do AWS CLI, use seu arquivo de definição de conexão e execute esse AWS CLI comando. Substitua o `region` espaço reservado pelo nome AWS da sua região e forneça o caminho local para seu arquivo de definição.
**nota**
O caminho para seu arquivo de definição de configuração deve ser precedido por `file://`.
```
aws --region region glue create-connection --cli-input-json file://path_to_file/sagemaker-sql-connection.json
```
Verifique se a AWS Glue conexão foi criada executando o comando a seguir e verifique o nome da conexão.
```
aws --region region glue get-connections
```
Como alternativa, você pode atualizar uma AWS Glue conexão existente da seguinte maneira:
+ Modifique o arquivo de definição de AWS Glue conexão conforme necessário.
+ Execute o comando a seguir para atualizar a conexão.
```
aws --region region glue update-connection --name glue_connection_name --cli-input-json file://path_to_file/sagemaker-sql-connection.json
```
# Crie conexões definidas pelo usuário AWS Glue
**nota**
Todas as AWS Glue conexões criadas pelos usuários por meio da interface de usuário da extensão SQL são automaticamente marcadas com o seguinte:
`UserProfile: user-profile-name`
`AppType: "JL"`
Essas tags aplicadas às AWS Glue conexões criadas por meio da interface de usuário da extensão SQL têm dois propósitos. A `"UserProfile": user-profile-name` tag permite a identificação do perfil de usuário específico que criou a AWS Glue conexão, fornecendo visibilidade ao usuário responsável pela conexão. A `"AppType": "JL"` tag categoriza a proveniência da conexão, associando-a ao aplicativo. JupyterLab Isso permite que essas conexões sejam diferenciadas daquelas que podem ter sido criadas por outros meios, como a AWS CLI.
## Pré-requisitos
Antes de criar uma AWS Glue conexão usando a interface de usuário da extensão SQL, verifique se você concluiu as seguintes tarefas:
+ Faça com que seu administrador:
+ Habilite a comunicação de rede entre o domínio do Studio e as fontes de dados às quais você deseja se conectar. Para saber quais são os requisitos de rede, consulte [Configurar o acesso à rede entre o Studio e as fontes de dados (para administradores)](sagemaker-sql-extension-networking.md).
+ As permissões necessárias do IAM devem estar configuradas para gerenciar conexões do AWS Glue e o acesso ao Secrets Manager. Para saber quais são as permissões necessárias, consulte [Configurar as permissões do IAM para acessar as fontes de dados (para administradores)](sagemaker-sql-extension-datasources-connection-permissions.md).
**nota**
Os administradores podem restringir o acesso do usuário somente às conexões que foram criadas por um usuário dentro do JupyterLab aplicativo. Isso pode ser feito configurando o [controle de acesso baseado em tags](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-sql-extension-datasources-connection-permissions.html#user-defined-connections-permissions) com escopo reduzido ao perfil de usuário.
+ Verifique as propriedades e instruções da conexão para criar um segredo para sua fonte de dados em [Criar segredos no Secrets Manager para credenciais de acesso de banco de dados](sagemaker-sql-extension-glue-connection-secrets.md).
## Fluxo de trabalho do usuário
As seguintes etapas apresentam o fluxo de trabalho do usuário ao criar conexões de usuário:
1. **Selecione o tipo de fonte de dados**: ao escolher o ícone de *adicionar nova conexão*, um formulário é aberto, solicitando que o usuário selecione o tipo de fonte de dados à qual deseja se conectar, como Amazon Redshift, Athena ou Snowflake.
1. **Forneça as propriedades da conexão**: com base na fonte de dados selecionada, as propriedades pertinentes da conexão são carregadas dinamicamente. O formulário indica quais campos são obrigatórios ou opcionais para a fonte de dados escolhida. Para saber quais propriedades estão disponíveis para sua fonte de dados, consulte [Parâmetros de conexão](sagemaker-sql-extension-connection-properties.md).
1. **Selecione seu AWS Secrets Manager ARN**: Para fontes de dados do Amazon Redshift e do Snowflake, o usuário é solicitado a selecionar o ARN do Secrets AWS Manager que armazena informações confidenciais, como nome de usuário e senha. Para saber como criar um segredo para sua fonte de dados, consulte[Criar segredos no Secrets Manager para credenciais de acesso de banco de dados](sagemaker-sql-extension-glue-connection-secrets.md).
1. **Salve os detalhes da conexão**: ao clicar em **Criar**, as propriedades da conexão fornecidas são salvas como uma conexão do AWS Glue .
1. **Teste sua conexão**: se a conexão tiver êxito, os bancos de dados e tabelas correspondentes ficarão visíveis no explorador. Se a conexão falhar, uma mensagem de erro será exibida, solicitando que o usuário analise e corrija os detalhes da conexão.
1. **Familiarize-se com os recursos da extensão de SQL**: para saber quais são os recursos da extensão, consulte [Atributos e uso da extensão SQL](sagemaker-sql-extension-features.md).
1. **(Opcional) Atualize ou exclua as conexões criadas pelo usuário**: desde que o usuário tenha recebido as permissões necessárias, ele poderá atualizar ou excluir as conexões que criou. Para saber mais sobre as permissões necessárias, consulte [Permissões do IAM necessárias para conexões definidas por usuários](sagemaker-sql-extension-datasources-connection-permissions.md#user-defined-connections-permissions).
# Configurar as permissões do IAM para acessar as fontes de dados (para administradores)
Os administradores devem garantir que a função de execução usada pelos JupyterLab aplicativos tenha as permissões necessárias do AWS IAM para acessar os dados por meio das AWS Glue conexões configuradas.
+ **Conexões criadas por administradores usando o AWS CLI**: Para visualizar as AWS Glue conexões [criadas pelos administradores](sagemaker-sql-extension-datasources-glue-connection.md) e acessar seus dados, os usuários precisam que o administrador atribua permissões específicas à função de execução de SageMaker IA usada pelo JupyterLab aplicativo no Studio. Isso inclui acesso ao AWS Glue Secrets Manager e permissões específicas do banco de dados. As conexões criadas por administradores são visíveis para todos as aplicações que compartilham um perfil de execução que recebeu as permissões para visualizar bancos de dados ou catálogos específicos do AWS Glue . Para saber mais sobre a lista de permissões necessárias por tipo de fonte de dados, consulte as permissões de conexões definidas por administradores em [Permissões do IAM necessárias para conexões definidas por administradores](#admin-defined-connections-permissions).
+ **Conexões criadas por usuários usando a interface de usuário da extensão SQL em JupyterLab**: As conexões [criadas por perfis de usuário](sagemaker-sql-extension-datasources-glue-connection-user-defined.md) que compartilham a mesma função de execução também serão listadas, a menos que a visibilidade de suas conexões seja reduzida apenas às criadas pelo usuário. As conexões criadas por usuários são marcadas com o perfil do usuário que as criou. Para restringir a capacidade de visualizar, atualizar ou excluir essas conexões criadas por usuários somente ao usuário que as criou, os administradores podem adicionar outras restrições de controle de acesso com base em tags às permissões do IAM do perfil de execução. Para saber qual controle de acesso baseado em tags adicional é necessário, consulte [Permissões do IAM necessárias para conexões definidas por usuários](#user-defined-connections-permissions).
## Permissões do IAM necessárias para conexões definidas por administradores
Para conceder à função de execução de SageMaker IA usada por seu JupyterLab aplicativo no Studio acesso a uma fonte de dados por meio de uma AWS Glue conexão, anexe a seguinte política embutida à função.
Para ver as permissões específicas e os detalhes da política para cada fonte de dados ou método de autenticação, escolha o tipo de conexão pertinente abaixo.
**nota**
Recomendamos limitar as permissões da sua política para somente recursos e ações necessários.
Para definir o escopo das políticas e conceder acesso com privilégios mínimos, substitua o curinga `"Resource": ["*"]` em sua política por um específico ARNs para os recursos exatos que precisam de acesso. Para obter mais informações sobre como controlar o acesso aos seus recursos, consulte [Ajuste o acesso aos AWS recursos com permissões granulares de ARN](#resource-access-control).
### Todos os tipos de conexão
**nota**
É altamente recomendável definir o escopo dessa política apenas para as ações e os recursos necessários.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "GetS3AndDataSourcesMetadata",
"Effect": "Allow",
"Action": [
"glue:GetDatabases",
"glue:GetSchema",
"glue:GetTables",
"s3:ListBucket",
"s3:GetObject",
"s3:GetBucketLocation",
"glue:GetDatabase",
"glue:GetTable",
"glue:ListSchemas",
"glue:GetPartitions"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:glue:us-east-1:111122223333:catalog",
"arn:aws:glue:us-east-1:111122223333:connection/*"
]
},
{
"Sid": "ExecuteQueries",
"Effect": "Allow",
"Action": [
"athena:ListDataCatalogs",
"athena:ListDatabases",
"athena:ListTableMetadata",
"athena:StartQueryExecution",
"athena:GetQueryExecution",
"athena:RunQuery",
"athena:StartSession",
"athena:GetQueryResults",
"athena:ListWorkGroups",
"s3:ListMultipartUploadParts",
"s3:ListBucket",
"s3:GetBucketLocation",
"athena:GetDataCatalog",
"s3:AbortMultipartUpload",
"s3:GetObject",
"s3:PutObject",
"athena:GetWorkGroup"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:athena:us-east-1:111122223333:workgroup/workgroup-name"
]
},
{
"Sid": "GetGlueConnections",
"Effect": "Allow",
"Action": [
"glue:GetConnections",
"glue:GetConnection"
],
"Resource": [
"arn:aws:glue:us-east-1:111122223333:catalog",
"arn:aws:glue:us-east-1:111122223333:connection/*"
]
},
{
"Sid": "GetSecrets",
"Effect": "Allow",
"Action": [
"secretsmanager:GetSecretValue"
],
"Resource": [
"arn:aws:secretsmanager:us-east-1:111122223333:secret:secret-name"
]
},
{
"Sid": "GetClusterCredentials",
"Effect": "Allow",
"Action": [
"redshift:GetClusterCredentials"
],
"Resource": [
"arn:aws:redshift:us-east-1:111122223333:cluster:cluster-name"
]
}
]
}
```
------
### Athena
**nota**
É altamente recomendável definir o escopo dessa política apenas para os recursos necessários.
Para obter mais informações, consulte *Exemplos de políticas de permissões do IAM* em [Documentação do Athena](https://docs.aws.amazon.com/athena/latest/ug/federated-query-iam-access.html).
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "GetS3AndDataSourcesMetadata",
"Effect": "Allow",
"Action": [
"glue:GetDatabases",
"glue:GetSchema",
"glue:GetTables",
"s3:ListBucket",
"s3:GetObject",
"s3:GetBucketLocation",
"glue:GetDatabase",
"glue:GetTable",
"glue:ListSchemas",
"glue:GetPartitions"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:glue:us-east-2:111122223333:catalog",
"arn:aws:glue:us-east-2:111122223333:connection/*"
]
},
{
"Sid": "ExecuteAthenaQueries",
"Effect": "Allow",
"Action": [
"athena:ListDataCatalogs",
"athena:ListDatabases",
"athena:ListTableMetadata",
"athena:StartQueryExecution",
"athena:GetQueryExecution",
"athena:RunQuery",
"athena:StartSession",
"athena:GetQueryResults",
"athena:ListWorkGroups",
"s3:ListMultipartUploadParts",
"s3:ListBucket",
"s3:GetBucketLocation",
"athena:GetDataCatalog",
"s3:AbortMultipartUpload",
"s3:GetObject",
"s3:PutObject",
"athena:GetWorkGroup"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:athena:us-east-2:111122223333:workgroup/workgroup-name"
]
},
{
"Sid": "GetGlueConnections",
"Effect": "Allow",
"Action": [
"glue:GetConnections",
"glue:GetConnection"
],
"Resource": [
"arn:aws:glue:us-east-2:111122223333:catalog",
"arn:aws:glue:us-east-2:111122223333:connection/*"
]
},
{
"Sid": "GetSecrets",
"Effect": "Allow",
"Action": [
"secretsmanager:GetSecretValue"
],
"Resource": [
"arn:aws:secretsmanager:us-east-2:111122223333:secret:secret-name"
]
}
]
}
```
------
### Amazon Redshift e Amazon Redshift sem servidor (autenticação de nome de usuário e senha) / Snowflake
**nota**
É altamente recomendável definir o escopo dessa política apenas para os recursos necessários.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "GetS3Metadata",
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:GetObject",
"s3:GetBucketLocation"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
},
{
"Sid": "GetGlueConnections",
"Effect": "Allow",
"Action": [
"glue:GetConnections",
"glue:GetConnection"
],
"Resource": [
"arn:aws:glue:us-east-2:111122223333:catalog",
"arn:aws:glue:us-east-2:111122223333:connection/*"
]
},
{
"Sid": "GetSecrets",
"Effect": "Allow",
"Action": [
"secretsmanager:GetSecretValue"
],
"Resource": [
"arn:aws:secretsmanager:us-east-2:111122223333:secret:secret-name"
]
}
]
}
```
------
### Amazon Redshift (autenticação do IAM)
**nota**
É altamente recomendável definir o escopo dessa política apenas para os recursos necessários.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "GetS3Metadata",
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:GetObject",
"s3:GetBucketLocation"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
},
{
"Sid": "GetGlueConnections",
"Effect": "Allow",
"Action": [
"glue:GetConnections",
"glue:GetConnection"
],
"Resource": [
"arn:aws:glue:us-east-1:111122223333:catalog",
"arn:aws:glue:us-east-1:111122223333:connection/*",
"arn:aws:glue:us-east-1:111122223333:connection/connection-name"
]
},
{
"Sid": "GetSecrets",
"Effect": "Allow",
"Action": [
"secretsmanager:GetSecretValue"
],
"Resource": [
"arn:aws:secretsmanager:us-east-1:111122223333:secret:secret-name",
"arn:aws:secretsmanager:us-east-1:111122223333:secret:secret-name-with-suffix"
]
},
{
"Sid": "GetClusterCredentials",
"Effect": "Allow",
"Action": [
"redshift:GetClusterCredentials"
],
"Resource": [
"arn:aws:redshift:us-east-1:111122223333:cluster:cluster-name",
"arn:aws:redshift:us-east-1:111122223333:dbuser:cluster-name/db-user-name"
]
}
]
}
```
------
### Amazon Redshift sem servidor (autenticação do IAM)
**nota**
É altamente recomendável definir o escopo dessa política apenas para os recursos necessários.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "GetS3Metadata",
"Effect": "Allow",
"Action": [
"s3:ListBucket",
"s3:GetObject",
"s3:GetBucketLocation"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/*"
]
},
{
"Sid": "GetGlueConnections",
"Effect": "Allow",
"Action": [
"glue:GetConnections",
"glue:GetConnection"
],
"Resource": [
"arn:aws:glue:us-east-2:111122223333:catalog",
"arn:aws:glue:us-east-2:111122223333:connection/*"
]
},
{
"Sid": "GetSecrets",
"Effect": "Allow",
"Action": [
"secretsmanager:GetSecretValue"
],
"Resource": [
"arn:aws:secretsmanager:us-east-2:111122223333:secret:secret-name"
]
},
{
"Sid": "GetRedshiftServerlessCredentials",
"Effect": "Allow",
"Action": [
"redshift-serverless:GetCredentials"
],
"Resource": [
"arn:aws:redshift-serverless:us-east-2:111122223333:namespace/namespace-id"
]
}
]
}
```
------
## Permissões do IAM necessárias para conexões definidas por usuários
As permissões da política do IAM para um usuário podem explicar a presença da `UserProfile` tag nos recursos de AWS Glue conexão.
+ **Para visualizar AWS Glue as conexões**:
+ Os usuários podem visualizar todas as conexões que não têm a tag `UserProfile` (criadas por um administrador).
+ Os usuários podem visualizar as conexões que têm a tag `UserProfile` com o mesmo valor do nome do perfil do usuário.
+ Os usuários não podem visualizar as conexões que têm a tag `UserProfile` com um valor diferente do nome do perfil do usuário.
+ **Para atualizar ou excluir AWS Glue conexões**:
+ Os usuários podem atualizar ou excluir uma conexão que tem a tag `UserProfile` com o mesmo valor do nome do perfil do usuário.
+ Os usuários não podem atualizar ou excluir uma conexão que tem a tag `UserProfile` com o mesmo valor do nome do perfil do usuário.
+ Os usuários não podem atualizar ou excluir conexões que não tenham a tag `UserProfile`.
Para isso, os administradores devem conceder à função de execução usada pelo JupyterLab aplicativo do perfil de usuário permissões adicionais além das permissões de conexões existentes definidas pelo [administrador](#admin-defined-connections-permissions). Especificamente, além das permissões necessárias para acessar AWS Glue conexões definidas pelo administrador, as duas permissões adicionais do IAM a seguir devem ser concedidas à função de execução do usuário:
+ Permissão para criar AWS Glue conexões e associar a `UserProfile` tag ao valor do nome do perfil do usuário.
+ Permissão para visualizar, atualizar e excluir AWS Glue conexões que tenham a `UserProfile` tag correspondente ao nome do perfil do usuário.
Essa permissão restringe o acesso às AWS Glue conexões com base em um valor específico da tag do perfil do usuário. Atualize o valor da tag `UserProfile` com o nome do perfil do usuário que você deseja segmentar.
```
"Action": [
"glue:GetConnection",
"glue:GetConnections"
],
"Resource": [
"arn:aws:glue:region:account_id:connection/*"
],
"Condition": {
"StringEqualsIfExists": {
"aws:ResourceTag/UserProfile": "user_profile_name"
}
}
```
Essa permissão restringe a capacidade de criar, atualizar e excluir conexões criadas pelo usuário somente às conexões criadas pelo perfil de usuário com o valor de tag `UserProfile` especificado.
```
"Action": [
"glue:DeleteConnection",
"glue:UpdateConnection",
"glue:CreateConnection",
"glue:TagResource"
],
"Resource": [
"arn:aws:glue:region:account_id:connection/*"
],
"Condition": {
"StringEquals": {
"aws:ResourceTag/UserProfile": "user_profile"
}
}
```
## Ajuste o acesso aos AWS recursos com permissões granulares de ARN
Para um controle mais refinado sobre o acesso aos seus AWS recursos, substitua o recurso curinga `"Resource": ["*"]` em suas políticas pelos nomes de recursos específicos da Amazon (ARNs) somente dos recursos que exigem acesso. Usar o caractere exato ARNs em vez de um curinga restringe o acesso aos recursos pretendidos.
+ **Use um bucket específico do Amazon S3 ARNs**
Por exemplo, `"arn:aws:s3:::bucket-name"` ou ` "arn:aws:s3:::bucket-name/*"` para operações em nível de bucket ou em nível de objeto.
Para obter informações sobre todos os tipos de recursos no Amazon S3, consulte [Tipos de recursos definidos pelo Amazon S3](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazons3.html#amazons3-resources-for-iam-policies).
+ **Use banco de AWS Glue dados específico ARNs**
Por exemplo, ` "arn:aws:glue:region:account-id:catalog"` ou ` "arn:aws:glue:region:account-id:database/db-name"`. Para obter informações sobre todos os tipos de recursos em AWS Glue, consulte [Tipos de recursos definidos por AWS Glue](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awsglue.html#awsglue-resources-for-iam-policies).
+ **Use um grupo de trabalho específico do Athena ARNs**
Por exemplo, `"arn:aws:athena:region:account-id:workgroup/workgroup-name"`. Para obter informações sobre todos os tipos de recursos no Athena, consulte [Tipos de recursos definidos pelo Athena](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonathena.html#amazonathena-resources-for-iam-policies).
+ **Use um AWS segredo específico do Secrets Manager ARNs**
Por exemplo, `"arn:aws:secretsmanager:region:account-id:secret:secret-name"`. Para obter informações sobre todos os tipos de recursos no AWS Secrets Manager, consulte [Tipos de recursos definidos pelo AWS Secrets Manager](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awssecretsmanager.html#awssecretsmanager-resources-for-iam-policies)
+ **Use um cluster específico do Amazon Redshift ARNs**
Por exemplo, `"arn:aws:redshift:region:account-id:cluster:cluster-name"`. Para obter informações sobre os tipos de recursos no Amazon Redshift, consulte [Tipos de recursos definidos pelo Amazon Redshift](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonredshift.html#amazonredshift-resources-for-iam-policies). Para obter informações sobre todos os tipos de recursos no Redshift Serverless, consulte [Tipos de recursos definidos pelo Redshift Serverless](https://docs.aws.amazon.com/service-authorization/latest/reference/list_amazonredshiftserverless.html#amazonredshiftserverless-resources-for-iam-policies).
# Perguntas frequentes
A seguir, são FAQs respondidas perguntas gerais comuns sobre a extensão SQL em JupyterLab.
## P: Onde posso encontrar os logs da extensão do SQL?
R: A extensão SQL grava seu log no arquivo de log geral do seu JupyterLab aplicativo no Studio. Você pode encontrar esses logs em `/var/log/apps/app_container.log`.
## P: Estou recebendo um erro: “UsageError: Cell magic `%%sm\$1sql` not found.”
R: Crie uma nova célula e carregue a extensão novamente usando `%load_ext amazon_sagemaker_sql_magic`.
## P: Como faço para listar os vários parâmetros do meu comando `%%sm_sql`?
R: Use `%%sm_sql?` para obter o conteúdo de ajuda do comando.
## P: Não consigo ver a visualização de descoberta de dados no painel lateral direito.
R: Certifique-se de que seu espaço use uma imagem SageMaker de distribuição versão 1.6 ou superior. Essas SageMaker imagens vêm pré-instaladas com a extensão.
Se você atualizou a imagem do espaço do seu JupyterLab aplicativo no Studio, atualize seu navegador.
## P: O painel direito não reflete com precisão as AWS Glue conexões configuradas.
R: Tente atualizar o painel direito usando o botão **Atualizar** no canto inferior direito da interface de usuário da extensão de SQL em seu caderno.
## P: As instruções SQL não são executadas conforme o esperado ou são executadas incorretamente.
R: Tente limpar as conexões em cache executando o comando mágico `%sm_sql_manage --clear-cached-connections`.
## P: Estou recebendo o erro: “Actual statement count 2 did not match the desired statement count 1”.
R: A extensão do SQL é compatível com somente a execução de uma consulta SQL por vez.
## Floco de neve FAQs
A seguir, são FAQs respondidas perguntas gerais comuns para usuários da extensão SQL que usam o Snowflake como fonte de dados.
### P: Estou recebendo o erro: “No active warehouse selected in the current session”. Selecione um warehouse ativo com o comando “usar warehouse”.
R: Isso pode acontecer se o warehouse padrão de um usuário não estiver selecionado. Execute o comando `USE WAREHOUSE warehouse_name` para cada sessão.
### P: Estou recebendo um erro: “o objeto '*foo*' não existe ou não está autorizado”.
R: Certifique-se de que seu usuário do Snowflake tenha acesso ao objeto especificado.
# Parâmetros de conexão
As tabelas a seguir detalham as propriedades Python suportadas para AWS Glue conexões por armazenamento de dados.
## Parâmetros de conexão do Amazon Redshift
Os seguintes parâmetros de conexão do Python são compatíveis com AWS Glue conexões com o Amazon Redshift.
| Chave | Tipo | Description | Restrições | Obrigatório |
| --- | --- | --- | --- | --- |
| auto\$1create | Tipo: boolean | Indica se o usuário deve ser criado se ele não existir. O padrão é false. | true, false | Não |
| aws\$1secret\$1arn | Tipo: string | O ARN do segredo usado para recuperar os parâmetros adicionais para a conexão. | ARN válido | Não |
| cluster\$1identifier | Tipo: string - maxLength: 63 | O identificador de clusters do cluster do Amazon Redshift. | ^(?\$1.\$1: )[a-z][a-z0-9-]\$10,61\$1[a-z0-9]\$1 | Não |
| database | Tipo: string - maxLength: 127 | É o nome do banco de dados ao qual se conectar. | | Não |
| database\$1metadata\$1current\$1db\$1only | Tipo: boolean | Indica se a aplicação oferece apoio a catálogos de unidade de compartilhamento de dados com vários bancos de dados. O valor padrão true indica que a aplicação não oferece apoio a catálogos de unidades de compartilhamento de dados de vários bancos de dados para compatibilidade com versões anteriores. | true, false | Não |
| db\$1groups | Tipo: string | Uma lista separada por vírgulas de nomes de grupos de bancos de dados existentes que o db\$1user se junta para a sessão atual. | | Não |
| db\$1user | Tipo: string | O ID de usuário a ser usado com o Amazon Redshift. | | Não |
| host | Tipo: string - maxLength: 256 | O nome de host do cluster do Amazon Redshift. | | Não |
| iam | Tipo: boolean | Sinalize para ativar ou desativar a autenticação baseada em IAM para uma conexão. O padrão é false. | true, false | Não |
| iam\$1disable\$1cache | Tipo: boolean | Essa opção especifica se as credenciais do IAM são armazenadas em cache. O padrão é true. Isso melhora o desempenho quando solicitações para o API Gateway têm controle de utilização. | true, false | Não |
| max\$1prepared\$1statements | Tipo: integer | O número máximo de instruções preparadas que podem ser abertas simultaneamente. | | Não |
| numeric\$1to\$1float | Decimal para ponto flutuante | Especifica se os valores do tipo de dados NUMERIC serão convertidos de decimal. Por padrão, os valores NUMERIC são recebidos como objetos Python decimal.Decimal. Não é recomendável ativar essa opção para casos de uso que preferem a maior precisão, pois os resultados podem ser arredondados. Consulte a documentação do Python em [https://docs.python.org/3/library/decimal.html#decimal-objects](https://docs.python.org/3/library/decimal.html#decimal-objects) para entender as vantagens e desvantagens entre decimal.Decimal e float antes de habilitar essa opção. O padrão é false. | true, false | Não |
| port | Tipo: integer | O número da porta do cluster Amazon Redshift. | Intervalo 1150-65535 | Não |
| profile | Tipo: string - maxLength: 256 | O nome do perfil que contém as credenciais e a configuração usadas pela AWS CLI. | | Não |
| region | Tipo: string | A AWS região em que o cluster está localizado. | AWS Região válida | Não |
| serverless\$1acct\$1id | Tipo: string - maxLength: 256 | O ID da AWS conta que está associado ao recurso sem servidor do Amazon Redshift. | | Não |
| serverless\$1work\$1group | Tipo: string - maxLength: 256 | O nome do grupo de trabalho do endpoint do Amazon Redshift sem servidor. | | Não |
| ssl | Tipo: boolean | true se o SSL estiver habilitado. | true, false | Não |
| ssl\$1mode | Tipo: enum[verify-ca, verify-full, null]) | A segurança da conexão com o Amazon Redshift. verify-ca (SSL deve ser usado, e o certificado do servidor deve ser verificado.) e verify-full (SSL deve ser usado. O certificado do servidor deve ser verificado, e o nome do host do servidor deve corresponder ao atributo do nome do host no certificado.) são compatíveis. Para ter mais informações, consulte [Configurar as opções de segurança para conexões](https://docs.aws.amazon.com/redshift/latest/mgmt/connecting-ssl-support.html) na documentação do Amazon Redshift. O padrão é verify-ca. | verify-ca, verify-full | Não |
| timeout | Tipo: integer | O número de segundos antes de a conexão com o servidor atingir o tempo limite. | 0 | Não |
## Parâmetros de conexão do Athena
Os seguintes parâmetros de conexão do Python são compatíveis com AWS Glue conexões com o Athena.
| Chave | Tipo | Description | Restrições | Obrigatório |
| --- | --- | --- | --- | --- |
| aws\$1access\$1key\$1id | Tipo: string - maxLength: 256 | Especifica uma chave de AWS acesso associada a uma conta do IAM. Recomendamos armazenar essas informações no aws\$1secret. | Comprimento 16-128 | Não |
| aws\$1secret\$1access\$1key | Tipo: string - maxLength: 256 | Parte secreta de uma chave de AWS acesso. Recomendamos armazenar essas informações no aws\$1secret. | | Não |
| aws\$1secret\$1arn | Tipo: string | O ARN do segredo usado para recuperar os parâmetros adicionais para a conexão. | ARN válido | Não |
| catalog\$1name | Tipo: string - maxLength: 256 | O catálogo que contém os bancos de dados e as tabelas que serão acessados com o driver. Para obter informações sobre catálogos, consulte [DataCatalog](https://docs.aws.amazon.com/athena/latest/APIReference/API_DataCatalog.html). | | Não |
| duration\$1seconds | Tipo: number | A duração, em segundos, da sessão do perfil. Essa configuração pode ter um valor de 1 hora a 12 horas. Por padrão, a duração está definida para 3.600 segundos (uma hora). | Pode variar de 900 segundos (15 minutos) até o valor configurado de duração máxima da sessão para o perfil | Não |
| encryption\$1option | Tipo: enum[SSE\$1S3, SSE\$1KMS, CSE\$1KMS, null]) | Criptografia em repouso para Amazon S3. Consulte a seção Criptografia em repouso no [Guia do Athena](https://docs.aws.amazon.com/athena/latest/ug/encryption.html). | SSE\$1S3, SSE\$1KMS, CSE\$1KMS | Não |
| kms\$1key | Tipo: string - maxLength: 256 | AWS KMS chave se estiver usando CSE\$1KMS emencrytion\$1option. | | Não |
| poll\$1interval | Tipo: number | Intervalo em segundos para pesquisar o status dos resultados da consulta no Athena. | | Não |
| profile\$1name | Tipo: string - maxLength: 256 | O nome do perfil de AWS configuração cujas credenciais devem ser usadas para autenticar a solicitação para o Athena. | | Não |
| region\$1name | Tipo: string | A AWS região em que as consultas são executadas. | AWS Região válida | Não |
| result\$1reuse\$1enable | Tipo: boolean | Habilite a reutilização do resultado da consulta anterior. | true, false | Não |
| result\$1reuse\$1minutes | Tipo: integer | Especifica, em minutos, a idade máxima de um resultado de consulta anterior que o Athena deverá considerar para reutilização. O padrão é 60. | >=1 | Não |
| role\$1arn | Tipo: string | Perfil a ser usado para executar consultas. | ARN válido | Não |
| schema\$1name | Tipo: string - maxLength: 256 | Nome do esquema padrão a ser usado para o banco de dados. | | Não |
| s3\$1staging\$1dir | Tipo: string - maxLength: 1024 | O local do Amazon S3 em que os resultados da consulta são armazenados. | | s3\$1staging\$1dir ou work\$1group é necessário. |
| work\$1group | Tipo: string | O grupo de trabalho no qual as consultas serão executadas. Para obter informações sobre grupos de trabalho, consulte [WorkGroup](https://docs.aws.amazon.com/athena/latest/APIReference/API_WorkGroup.html). | ^[a-zA-Z0-9.\$1-]\$11,128\$1\$1 | s3\$1staging\$1dir ou work\$1group é necessário. |
## Parâmetros de conexão do Snowflake
Os seguintes parâmetros de conexão do Python são compatíveis com AWS Glue conexões com o Snowflake.
Parâmetros de conexão do Snowflake
| Chave | Tipo | Description | Restrições | Obrigatório |
| --- | --- | --- | --- | --- |
| account | Tipo: string - maxLength: 256 | O identificador da conta do Snowflake. O identificador da conta não inclui o sufixo snowflakecomputing.com. | | Sim |
| arrow\$1number\$1to\$1decimal | Tipo: boolean | “False” por padrão, o que significa que os valores da coluna “NUMBER” são retornados como números de ponto flutuante de precisão dupla (float64). Defina isso como “True” para retornar os valores da coluna “DECIMAL” como números decimais (decimal.Decimal) ao chamar os métodos fetch\$1pandas\$1all() e fetch\$1pandas\$1batches(). | true, false | Não |
| autocommit | Tipo: boolean | O padrão é false, que respeita o parâmetro do Snowflake AUTOCOMMIT. Defina true ou false para ativar ou desativar o modo autocommit na sessão, respectivamente. | true, false | Não |
| aws\$1secret\$1arn | Tipo: string | O ARN do segredo usado para recuperar os parâmetros adicionais para a conexão. | ARN válido | Não |
| client\$1prefetch\$1threads | Tipo: integer | O número de threads usados para baixar os conjuntos de resultados (4 por padrão). Aumentar o valor melhora o desempenho da busca, mas requer mais memória. | | Não |
| database | Tipo: string - maxLength: 256 | O nome do banco de dados padrão a ser excluído. | | Não |
| login\$1timeout | Tipo: integer | O tempo limite em segundos da solicitação de login. O padrão é 60 segundos. A solicitação de login desiste após o tempo limite se a resposta do HTTP não for success. | | Não |
| network\$1timeout | Tipo: integer | O tempo limite em segundos para as outras operações. O padrão é none (infinito). Uma solicitação geral desiste após o tempo limite se a resposta do HTTP não for success. | | Não |
| paramstyle | Tipo: string - maxLength: 256 | Sintaxes de espaço reservado usadas para substituição de parâmetros ao executar consultas SQL a partir do código Python. O padrão é pyformat para vinculação do lado do cliente. Especifique qmark ou numeric para alterar os formatos das variáveis de associação para vinculação do lado do servidor. | | Não |
| role | Tipo: string - maxLength: 256 | O nome do perfil padrão a ser usado. | | Não |
| schema | Tipo: string - maxLength: 256 | O nome do esquema padrão a ser usado para o banco de dados. | | Não |
| timezone | Tipo: string - maxLength: 128 | Nenhum por padrão, o que respeita o parâmetro TIMEZONE do Snowflake. Defina um fuso horário válido (como America/Los\$1Angeles) para definir o fuso horário da sessão. | Fuso horário em um formato semelhante ao America/Los\$1Angeles | Não |
| validate\$1default\$1parameters | Tipo: boolean | Defina como true para gerar uma exceção se o banco de dados, esquema ou warehouse especificado não existir. O padrão é false. | | Não |
| warehouse | Tipo: string - maxLength: 256 | O nome do warehouse padrão a ser usado. | | Não |
# Preparação de dados em grande escala usando aplicaçãos do Amazon EMR Sem Servidor ou clusters do Amazon EMR no Studio
O Amazon SageMaker Studio e sua versão antiga, o Studio Classic, fornecem aos cientistas de dados e engenheiros de aprendizado de máquina (ML) ferramentas para realizar análises e preparação de dados em grande escala. Analisar, transformar e preparar grandes quantidades de dados é uma etapa fundamental de qualquer fluxo de trabalho de ciência de dados e ML. Tanto o Studio quanto o Studio Classic vêm com integração integrada com o Amazon EMR, permitindo que os usuários gerenciem fluxos de trabalho interativos de preparação de dados e aprendizado de máquina em grande escala em seus notebooks. JupyterLab
[O [Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-what-is-emr.html) é uma plataforma gerenciada de big data com recursos para ajudá-lo a executar trabalhos de processamento de dados distribuídos em escala de petabytes usando estruturas de análise de código aberto, AWS como [Apache Spark, [Apache](https://aws.amazon.com/emr/features/hive) Hive, Presto e Flink](https://aws.amazon.com/emr/features/spark), entre outras.](https://aws.amazon.com/emr/features/presto) HBase Com a integração do Studio e do Studio Classic com o Amazon EMR, você pode criar, navegar, descobrir e se conectar aos clusters do Amazon EMR sem sair do seu notebook JupyterLab ou do Studio Classic. Você também pode monitorar e depurar suas workloads do Spark acessando a interface de usuário do Spark com um clique, diretamente de seu caderno.
Você deve considerar os clusters do Amazon EMR para suas workloads de preparação de dados se tiver requisitos de processamento de dados em grande escala, de longa duração ou complexos que envolvam grandes quantidades de dados, exijam ampla personalização e integração com outros serviços, precise executar aplicações personalizados ou planeje executar uma variedade diversificada de estruturas de processamento de dados distribuídas além do Apache Spark.
Usando [imagem SageMaker de distribuição](sagemaker-distribution.md) `1.10` ou superior, você pode se conectar alternativamente a aplicativos [EMR Serverless](https://docs.aws.amazon.com/emr/latest/EMR-Serverless-UserGuide/emr-serverless.html) interativos diretamente de seus JupyterLab notebooks no AI Studio. SageMaker A integração do Studio com o EMR Sem Servidor permite que você execute frameworks de big data analytics de código aberto, como [Apache Spark](https://aws.amazon.com/emr/features/spark) e [Apache Hive](https://aws.amazon.com/emr/features/hive), sem configurar, gerenciar ou escalar clusters do Amazon EMR. O EMR Sem Servidor provisiona e gerencia automaticamente os recursos de computação e memória subjacentes com base nas necessidades da aplicação do EMR Sem Servidor. Ele aumenta e reduz a escala dos recursos verticalmente e dinamicamente, cobrando você ou a quantidade de recursos de vCPU, memória e armazenamento consumidos por suas aplicações. Essa abordagem sem servidor permite que você [execute cargas de trabalho interativas de preparação de dados](https://docs.aws.amazon.com/emr/latest/EMR-Serverless-UserGuide/interactive-workloads.html) em seus JupyterLab notebooks sem se preocupar com o gerenciamento de clusters, ao mesmo tempo em que obtém alta utilização da instância e eficiência de custos.
Você deve considerar o EMR Sem Servidor para suas workloads de preparação de dados interativos se elas forem de curta duração ou intermitentes e não exigirem um cluster persistente; se você preferir uma experiência sem servidor com provisionamento e encerramento automáticos de recursos, evitando a sobrecarga de gerenciar a infraestrutura; ou se suas tarefas de preparação de dados interativos girarem principalmente em torno do Apache Spark.
**Topics**
+ [Configurar o acesso à rede para o cluster do Amazon EMR](studio-notebooks-emr-networking.md)
+ [Preparar dados usando o EMR Sem Servidor](studio-notebooks-emr-serverless.md)
+ [Preparação de dados usando o Amazon EMR](studio-notebooks-emr-cluster.md)
# Configurar o acesso à rede para o cluster do Amazon EMR
Antes de começar a usar o Amazon EMR ou o EMR Sem Servidor para suas tarefas de preparação de dados no Studio, certifique-se de que você ou seu administrador tenham configurado sua rede para permitir a comunicação entre o Studio e o Amazon EMR. Depois que essa comunicação estiver ativada, você poderá escolher:
+ [Preparar dados usando o EMR Sem Servidor](studio-notebooks-emr-serverless.md)
+ [Preparação de dados usando o Amazon EMR](studio-notebooks-emr-cluster.md)
**nota**
Para usuários do EMR Sem Servidor, a configuração mais simples envolve criar sua aplicação na interface de usuário do Studio sem modificar as configurações padrão da opção de **nuvem privada virtual (VPC)**. Essa abordagem permite que o aplicativo seja criado na VPC do seu SageMaker domínio, eliminando a necessidade de configuração adicional de rede. Se escolher essa opção, ignore a seguinte seção de configuração de rede:
As instruções de rede variam de acordo com o fato de o Studio e o Amazon EMR estarem implantados em uma [nuvem privada virtual (VPC)](https://docs.aws.amazon.com/vpc/latest/userguide/what-is-amazon-vpc.html) da Amazon ou se comunicarem pela internet.
Por padrão, o Studio ou o Studio Classic são executados em uma VPC AWS gerenciada com [acesso à Internet](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-notebooks-and-internet-access.html#studio-notebooks-and-internet-access-default). Ao usar uma conexão com a Internet, o Studio e o Studio Classic acessam AWS recursos, como buckets do Amazon S3, pela Internet. No entanto, se você tiver requisitos de segurança para controlar o acesso aos contêineres de dados e tarefas, recomendamos que você configure o Studio ou o Studio Classic e o Amazon EMR para que seus dados e contêineres não fiquem acessíveis pela internet. Para controlar o acesso aos seus recursos ou executar o Studio ou o Studio Classic sem acesso público à Internet, você pode especificar o tipo de acesso à `VPC only` rede ao fazer a integração com o [domínio Amazon SageMaker AI](gs-studio-onboard.md). Nesse cenário, tanto o Studio quanto o Studio Classic estabelecem conexões com outros AWS serviços por meio de [VPC](https://docs.aws.amazon.com/vpc/latest/privatelink/create-interface-endpoint.html) endpoints privados. Para obter informações sobre como configurar o Studio ou o Studio Classic no `VPC only` modo, consulte [Conectar notebooks SageMaker Studio ou Studio Classic em uma VPC](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-notebooks-and-internet-access.html#studio-notebooks-and-internet-access-vpc-only) a recursos externos. .
As duas primeiras seções descrevem como garantir a comunicação entre o Studio ou o Studio Classic e o Amazon EMR VPCs sem acesso público à Internet. A última seção aborda como garantir a comunicação entre o Studio ou o Studio Classic e o Amazon EMR usando uma conexão com a internet. Antes de conectar o Studio ou o Studio Classic ao Amazon EMR sem acesso à Internet, certifique-se de estabelecer endpoints para o Amazon Simple Storage Service (armazenamento de dados), Amazon (registro e monitoramento) e Amazon SageMaker Runtime CloudWatch (controle de acesso baseado em funções (RBAC) refinado).
Para conectar o Studio ou o Studio Classic ao Amazon EMR:
+ Se o Studio ou o Studio Classic e o Amazon EMR estiverem separados VPCs, na mesma AWS conta ou em contas diferentes, consulte. [O Studio e o Amazon EMR estão separados VPCs](#studio-notebooks-emr-networking-requirements-cross-vpc)
+ Se o Studio ou o Studio Classic e o Amazon EMR estiverem na mesma VPC, consulte [Studio e Amazon EMR na mesma VPC](#studio-notebooks-emr-networking-requirements-same-vpc).
+ Se você optar por conectar o Studio ou o Studio Classic e o Amazon EMR pela internet pública, consulte [Studio e Amazon EMR se comunicam pela Internet pública](#studio-notebooks-emr-networking-requirements-internet).
## O Studio e o Amazon EMR estão separados VPCs
Para permitir a comunicação entre o Studio ou o Studio Classic e o Amazon EMR quando eles são implantados separadamente: VPCs
1. Comece conectando seu por VPCs meio de uma conexão de emparelhamento VPC.
1. Atualize suas tabelas de rotas em cada VPC para rotear o tráfego de rede entre as sub-redes do Studio ou Studio Classic e as sub-redes do Amazon EMR nos dois sentidos.
1. Configure seus grupos de segurança da VPC para permitir tráfego de entrada e saída.
As etapas para conectar o Studio ou o Studio Classic e o Amazon EMR são as mesmas, independentemente de os recursos serem implantados em uma única AWS conta (caso de uso de conta única) ou em várias AWS contas (caso de uso entre contas).
1.
**emparelhamento da VPC**
Crie uma [conexão de emparelhamento VPC](https://docs.aws.amazon.com/vpc/latest/peering/working-with-vpc-peering.html) para facilitar a rede entre os dois VPCs (Studio ou Studio Classic e Amazon EMR).
1. Na sua conta do Studio ou Studio Classic, no painel da VPC, escolha **Conexões de emparelhamento** e, em seguida, **Criar conexão de emparelhamento**.
1. Crie sua solicitação para emparelhar a VPC do Studio ou Studio Classic com a VPC do Amazon EMR. Ao solicitar o emparelhamento em outra AWS conta, escolha **Outra conta** em **Selecionar outra VPC para fazer** o peering.
Para emparelhamento de contas cruzadas, o administrador deve aceitar a solicitação da conta do Amazon EMR.
Ao emparelhar sub-redes privadas, você deve ativar a resolução de DNS de IP privado na conexão de emparelhamento de VPC.
1.
**Tabelas de rotas**
Envie o tráfego de rede entre as sub-redes do Studio ou Studio Classic e as sub-redes do Amazon EMR nos dois sentidos.
Depois de estabelecer a conexão de emparelhamento, o administrador (em cada conta para acesso entre contas) pode adicionar rotas às tabelas de rotas da sub-rede privada para rotear o tráfego entre o Studio ou Studio Classic e as sub-redes do Amazon EMR. Você pode definir essas rotas acessando a seção **Tabelas de rotas** de cada VPC no painel da VPC.
A ilustração a seguir da tabela de rotas de uma sub-rede de VPC do Studio mostra um exemplo de uma rota de saída da conta do Studio para o intervalo de IP da VPC do Amazon EMR (aqui `2.0.1.0/24`) por meio da conexão de emparelhamento.
![\[Tabela de rotas de uma sub-rede da VPC do Studio mostrando as rotas de saída da conta do Studio para a faixa de IP da VPC do Amazon EMR (aqui 2.0.1.0/24) por meio da conexão de emparelhamento\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/emr/studio-notebooks-emr-return-route.png)
A ilustração a seguir de uma tabela de rotas de uma sub-rede da VPC do Amazon EMR mostra um exemplo de rotas de retorno do intervalo de IP do Amazon EMR VPC para o Studio VPC (aqui `10.0.20.0/24`) por meio da conexão de emparelhamento.
![\[Tabela de rotas de uma sub-rede da VPC do Amazon EMR mostrando as rotas de retorno da conta do Amazon EMR para o intervalo de IP da VPC do Studio (aqui 10.0.20.0/24) por meio da conexão de emparelhamento\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/emr/studio-notebooks-emr-outbound-route.png)
1.
**Grupos de segurança**
Por fim, o grupo de segurança do domínio do Studio ou Studio Classic deve permitir o tráfego de saída, e o grupo de segurança do nó primário do Amazon EMR deve permitir o tráfego de entrada nas portas TCP *Apache Livy*, *Hive* ou *Presto* (respectivamente, `8998`, `10000` e `8889`) vindo do grupo de segurança da instância do Studio ou Studio Classic. O [Apache Livy](https://livy.apache.org/) é um serviço que permite a interação com o Amazon EMR por meio de uma interface REST.
O diagrama a seguir mostra um exemplo de uma configuração do Amazon VPC que permite JupyterLab que os notebooks Studio Classic provisionem clusters do Amazon EMR a partir de modelos CloudFormation no Service Catalog e depois se conectem a um cluster do Amazon EMR na mesma conta. AWS O diagrama fornece uma ilustração adicional dos endpoints necessários para uma conexão direta com vários AWS serviços, como Amazon S3 ou CloudWatch Amazon, quando eles não têm acesso VPCs à Internet. Como alternativa, um [gateway NAT](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html#nat-gateway-working-with) deve ser usado para permitir que instâncias em sub-redes privadas de várias VPCs compartilhem um único endereço IP público fornecido pelo [gateway da Internet](https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Internet_Gateway.html) ao acessar a Internet.
![\[Diagrama arquitetônico ilustrando um exemplo de uma configuração simples do Amazon VPC que permite que os notebooks Studio ou Studio Classic CloudFormation provisionem clusters do Amazon EMR a partir de modelos no Service Catalog e depois se conectem a um cluster do Amazon EMR na mesma conta. AWS O diagrama fornece uma ilustração adicional dos endpoints necessários para uma conexão direta com vários AWS serviços, como Amazon S3 ou CloudWatch Amazon, quando eles não têm acesso VPCs à Internet. Como alternativa, um gateway NAT deve ser usado para permitir que instâncias em sub-redes privadas de várias VPCs compartilhem um único endereço IP público fornecido pelo gateway da Internet ao acessar a Internet.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/emr/studio-notebooks-emr-architecture-singleaccount-vpcendpoints.png)
## Studio e Amazon EMR na mesma VPC
Se o Studio ou o Studio Classic e o Amazon EMR estiverem em sub-redes diferentes, adicione rotas a cada tabela de rotas de sub-rede privada para rotear o tráfego entre o Studio ou o Studio Classic e as sub-redes do Amazon EMR. Você pode definir essas rotas acessando a seção **Tabelas de rotas** de cada VPC no painel da VPC. Se você implantou o Studio ou o Studio Classic e o Amazon EMR na mesma VPC e na mesma sub-rede, não precisa rotear o tráfego entre o Studio e o Amazon EMR.
Independentemente de você precisar atualizar suas tabelas de roteamento, o grupo de segurança do domínio do Studio ou Studio Classic deve permitir o tráfego de saída, e o grupo de segurança do nó primário do Amazon EMR deve permitir tráfego de entrada nas portas TCP *Apache Livy*, *Hive* ou *Presto* (respectivamente, `8998`, `10000` e `8889`) vindo do grupo de segurança da instância do Studio ou Studio Classic. O [Apache Livy](https://livy.apache.org/) é um serviço que permite a interação com o Amazon EMR por meio de uma interface REST.
## Studio e Amazon EMR se comunicam pela Internet pública
Por padrão, o Studio e o Studio Classic fornecem uma interface de rede que permite a comunicação com a Internet por meio de um gateway de Internet na VPC associada ao SageMaker domínio. Se você optar por se conectar ao Amazon EMR pela internet pública, o Amazon EMR precisará aceitar o tráfego de entrada nas portas TCP *Apache Livy*, *Hive* ou *Presto* (respectivamente, `8998`, `10000` e `8889`) do gateway da internet. O [Apache Livy](https://livy.apache.org/) é um serviço que permite a interação com o Amazon EMR por meio de uma interface REST.
Lembre-se de que qualquer porta na qual você permita o tráfego de entrada representa uma possível vulnerabilidade de segurança. Revise atentamente os grupos de segurança personalizados para minimizar vulnerabilidades. Para obter mais informações, consulte [Controlar o tráfego de rede com grupos de segurança](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-security-groups.html).
Como alternativa, consulte [Blogs e guias técnicos](studio-notebooks-emr-resources.md) para obter uma explicação passo a passo de como habilitar o [Kerberos no Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-kerberos.html), configurar o cluster em uma sub-rede privada e acessar o cluster usando um [Network Load Balancer (NLB)](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/introduction.html) para expor somente portas específicas, que são controladas pelo acesso por meio de grupos de segurança.
**nota**
Ao se conectar ao endpoint do Apache Livy pela internet pública, recomendamos que você proteja as comunicações entre o Studio ou o Studio Classic e o cluster do Amazon EMR usando TLS.
Para obter informações sobre como configurar o HTTPS com o Apache Livy, consulte [Como habilitar o HTTPS com o Apache Livy](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/enabling-https.html). Para obter informações sobre como configurar um cluster do Amazon EMR com a criptografia de trânsito ativada, consulte [Fornecimento de certificados para criptografar dados em trânsito com a criptografia do Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-encryption-enable.html#emr-encryption-certificates). Além disso, é necessário configurar o Studio ou o Studio Classic para acessar a chave de certificado conforme especificado em [Conecte-se a um cluster do Amazon EMR por HTTPS](connect-emr-clusters.md#connect-emr-clusters-ssl).
# Preparar dados usando o EMR Sem Servidor
Começando com a versão [da imagem de SageMaker distribuição](sagemaker-distribution.md)`1.10`, o Amazon SageMaker Studio se integra ao EMR Serverless. Nos JupyterLab notebooks do SageMaker Studio, cientistas e engenheiros de dados podem descobrir e se conectar aos aplicativos EMR Serverless e, em seguida, explorar, visualizar e preparar de forma interativa cargas de trabalho Apache Spark ou Apache Hive. Essa integração permite realizar o pré-processamento interativo de dados em grande escala na preparação para o treinamento e a implantação do modelo de ML.
Especificamente, a versão atualizada da versão de imagem de [distribuição [https://pypi.org/project/sagemaker-studio-analytics-extension/](https://pypi.org/project/sagemaker-studio-analytics-extension/)in SageMaker AI](https://github.com/aws/sagemaker-distribution/tree/main/build_artifacts/v1) `1.10` aproveita a integração entre o Apache Livy e o EMR Serverless, permitindo a conexão com um endpoint Apache Livy por meio de notebooks. JupyterLab Esta seção pressupõe conhecimento prévio das aplicações[ interativos do EMR Sem Servidor](https://docs.aws.amazon.com/EMR-Serverless-UserGuide/interactive-workloads.html).
**Importante**
Ao usar o Studio, você só pode descobrir e se conectar aos aplicativos EMR Serverless para JupyterLab aplicativos que são iniciados a partir de espaços privados. Certifique-se de que os aplicativos EMR Serverless estejam localizados na mesma AWS região do seu ambiente Studio.
## Pré-requisitos
Antes de começar a executar cargas de trabalho interativas com o EMR Serverless em JupyterLab seus notebooks, certifique-se de atender aos seguintes pré-requisitos:
1. Seu JupyterLab espaço deve usar uma versão SageMaker de imagem de distribuição `1.10` ou superior.
1. Crie uma aplicação interativa do EMR Sem Servidor com a versão `6.14.0` ou posterior do Amazon EMR. Você pode criar uma aplicação do EMR Sem Servidor por meio da interface de usuário do Studio seguindo as etapas em [Criar aplicações do EMR Sem Servidor a partir do Studio](create-emr-serverless-application.md).
**nota**
Para uma configuração mais simples, você pode criar sua aplicação do EMR Sem Servidor na interface de usuário do Studio sem alterar nenhuma configuração padrão da opção **Nuvem privada virtual (VPC)**. Isso permite que a aplicação seja criado na VPC do domínio sem exigir nenhuma configuração de rede. Nesse caso, você pode ignorar a etapa de configuração de rede a seguir.
1. Analise os requisitos de rede e segurança em [Configurar o acesso à rede para o cluster do Amazon EMR](studio-notebooks-emr-networking.md). Especificamente, confira se você:
+ Estabeleceu uma conexão de emparelhamento de VPC entre sua conta do Studio e sua conta do EMR Sem Servidor.
+ Adicionou rotas às tabelas de rotas da sub-rede privada em ambas as contas.
+ Configurou o grupo de segurança anexado ao seu domínio do Studio para permitir o tráfego de saída e o grupo de segurança da VPC em que pretende executar as aplicações do EMR Sem Servidor para permitir o tráfego TCP de entrada vindo do grupo de segurança da instância do Studio.
1. Para acessar seus aplicativos interativos no EMR Serverless e executar cargas de trabalho enviadas de seus JupyterLab notebooks no SageMaker Studio, você deve atribuir permissões e funções específicas. Consulte a seção [Configure as permissões para permitir a listagem e o lançamento de aplicativos do Amazon EMR a partir do Studio SageMaker](studio-emr-serverless-permissions.md) para obter detalhes sobre as funções e permissões necessárias.
**Topics**
+ [Pré-requisitos](#studio-set-up-emr-serverless-prerequisites)
+ [Configure as permissões para permitir a listagem e o lançamento de aplicativos do Amazon EMR a partir do Studio SageMaker](studio-emr-serverless-permissions.md)
+ [Criar aplicações do EMR Sem Servidor a partir do Studio](create-emr-serverless-application.md)
+ [Conecte-se a uma aplicação do EMR Sem Servidor a partir do Studio](connect-emr-serverless-application.md)
+ [Pare ou exclua uma aplicação do EMR Sem Servidor a partir da interface do Studio](terminate-emr-serverless-application.md)
# Configure as permissões para permitir a listagem e o lançamento de aplicativos do Amazon EMR a partir do Studio SageMaker
Nesta seção, detalhamos as funções e permissões necessárias para listar e conectar-se aos aplicativos EMR Serverless do SageMaker Studio, considerando cenários em que o Studio e os aplicativos EMR Serverless são implantados na mesma conta ou em contas diferentes. AWS
*As funções às quais você deve adicionar as permissões necessárias dependem de o Studio e seus aplicativos EMR Serverless residirem na mesma AWS conta (conta *única) ou em contas separadas (conta* cruzada).* Há dois tipos de funções envolvidas:
+ Perfis de execução:
+ Funções [de execução em tempo de execução (funções](https://docs.aws.amazon.com/http://emr/latest/EMR-Serverless-UserGuide/jobs-spark.html#spark-defaults-executionRoleArn) de controle de acesso baseado em função) usadas pelo EMR Serverless: essas são as funções do IAM usadas pelos ambientes de execução de tarefas do EMR Serverless para acessar outros AWS serviços e recursos necessários durante o tempo de execução, como o Amazon S3 para acesso a dados, registro em log, CloudWatch acesso ao catálogo de dados ou outros serviços com base em seus requisitos de carga de trabalho. AWS Glue Recomendamos criar essas funções na conta em que as aplicações do EMR Sem Servidor estão sendo executadas.
Para saber mais sobre as funções de runtime, consulte [Funções de runtime de trabalho](https://docs.aws.amazon.com/emr/latest/EMR-Serverless-UserGuide/security-iam-runtime-role.html) no *Guia do usuário do EMR Sem Servidor*.
**nota**
Você pode definir várias funções do RBAC para sua aplicação do EMR Sem Servidor. Essas funções podem ser baseadas nas responsabilidades e nos níveis de acesso necessários para diferentes usuários ou grupos em sua organização. Para obter mais informações sobre as permissões do RBAC, consulte [Melhores práticas de segurança para o Amazon EMR Sem Servidor da Amazon](https://docs.aws.amazon.com/emr/latest/EMR-Serverless-UserGuide/security-best-practices.html#security-practice-rbac).
+ SageMaker Função de execução de IA: a função de execução que permite à SageMaker IA realizar determinadas tarefas, como ler dados de buckets do Amazon S3, gravar registros e acessar outros AWS serviços que seu fluxo de trabalho possa precisar. CloudWatch A função de execução de SageMaker IA também tem a permissão especial chamada, `iam:PassRole` que permite que a SageMaker IA passe funções temporárias de execução de tempo de execução para os aplicativos EMR Serverless. Essas funções dão aos aplicativos EMR Serverless as permissões necessárias para interagir com outros AWS recursos enquanto estão em execução.
+ Perfis assumíveis (também conhecidos como *Service Access Roles*):
+ Essas são as funções do IAM que a função de execução da SageMaker IA pode assumir para realizar operações relacionadas ao gerenciamento de aplicativos EMR Serverless. Esses perfis definem as permissões e as políticas de acesso necessárias ao listar, realizar conexão ou gerenciar aplicações do EMR Sem Servidor. Eles geralmente são usados em cenários entre contas, em que os aplicativos EMR Serverless estão localizados em uma conta AWS diferente do domínio de IA. SageMaker Ter uma função de IAM dedicada para seus aplicativos EMR Serverless ajuda a seguir o princípio do menor privilégio e garante que o Amazon EMR tenha somente as permissões necessárias para executar seus trabalhos e, ao mesmo tempo, proteger outros recursos em sua conta. AWS
Ao entender e configurar essas funções corretamente, você pode garantir que o SageMaker Studio tenha as permissões necessárias para interagir com os aplicativos EMR Serverless, independentemente de estarem implantados na mesma conta ou em contas diferentes.
## Conta única
Os diagramas a seguir ilustram as funções e permissões necessárias para listar e conectar-se aos aplicativos EMR Serverless do Studio quando o Studio e os aplicativos são implantados na mesma conta. AWS
![\[O diagrama mostra as funções e permissões necessárias para listar e conectar aplicativos EMR Serverless do Studio quando o Studio e os aplicativos estão na mesma conta. AWS\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/emr/studio-notebooks-emr-serverless-permissions-setup-singleaccount.png)
Se seus aplicativos Amazon EMR e o Studio estiverem implantados na mesma AWS conta, siga estas etapas:
1. **Etapa 1**: recupere o ARN do bucket do Amazon S3 que você usa para fontes de dados e armazenamento de dados de saída no [console do Amazon S3.](https://console.aws.amazon.com/S3)
Para saber como encontrar um bucket pelo nome, consulte [Como acessar e listar um bucket do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-bucket-intro.html). Para obter informações sobre como criar um bucket do Amazon S3, consulte [Criar um bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html).
1. **Etapa 2**: crie pelo menos uma função de runtime de trabalho para sua aplicação do EMR Sem Servidor em sua conta (o `EMRServerlessRuntimeExecutionRoleA` no diagrama de caso de uso de *conta única* acima). Escolha **Política de confiança personalizada** como entidade confiável. Adicione as permissões necessárias por trabalho. No mínimo, você precisa de acesso total a um bucket do Amazon S3 e acesso de criação e leitura ao catálogo de AWS Glue dados.
Para obter instruções detalhadas sobre como criar uma nova função de runtime para suas aplicações do EMR Sem Servidor, siga estas etapas:
1. Navegue até o [console do IAM](https://console.aws.amazon.com/iam).
1. No painel de navegação à esquerda, selecione **Política** e, depois, **Criar política**.
1. Adicione as permissões exigidas pela sua função de runtime, nomeie a política e escolha **Criar política**.
Você pode consultar [Funções de runtime de trabalho do EMR Sem Servidor](https://docs.aws.amazon.com/emr/latest/EMR-Serverless-UserGuide/security-iam-runtime-role.html) para encontrar exemplos de políticas de runtime para uma função de runtime do EMR Sem Servidor.
1. No painel de navegação à esquerda, selecione **Funções** e, em seguida, **Criar função**.
1. Na página **Criar função**, escolha a opção **Política de confiança personalizada** como entidade confiável.
1. Cole o seguinte documento JSON na seção **Política de confiança personalizada** e escolha **Avançar**:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "emr-serverless.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Na página **Adicionar permissões**, selecione a política criada e, depois, **Avançar**.
1. Na página **Revisar**, insira um nome para a função, como `EMRServerlessAppRuntimeRoleA`, e uma descrição opcional.
1. Revisar os detalhes do perfil e selecionar **Criar perfil**.
Com esse recurso, você e seus colegas de equipe podem se conectar ao mesma aplicação, cada um usando uma função de runtime com permissões correspondentes ao seu nível individual de acesso aos dados.
**nota**
As sessões do Spark funcionam de forma diferente. As sessões do Spark são isoladas com base no perfil de execução usado no Studio, portanto, usuários com perfis de execução diferentes terão sessões do Spark separadas e isoladas. Além disso, se você habilitou a identidade de origem para seu domínio, haverá um isolamento adicional das sessões do Spark em diferentes identidades de origem.
1. **Etapa 3**: Recupere o ARN da função de execução SageMaker de IA usada pelo seu espaço privado.
Para obter informações sobre espaços e funções de execução na SageMaker IA, consulte[Compreendendo as permissões de espaço e os perfis de execução do domínio](execution-roles-and-spaces.md).
Para obter mais informações sobre como recuperar o ARN da função de execução SageMaker da IA, consulte. [Obtenha um perfil de execução](sagemaker-roles.md#sagemaker-roles-get-execution-role)
**nota**
Como alternativa, usuários iniciantes na SageMaker IA podem simplificar o processo de configuração criando automaticamente uma nova função de execução de SageMaker IA com as permissões apropriadas. Nesse caso, pule as etapas 3 e 4. Em vez disso, os usuários podem:
Escolha a opção **Configurar para organizações** ao criar um novo domínio no menu **Domínio** na navegação à esquerda do [console de SageMaker IA](https://console.aws.amazon.com/sagemaker).
Criar um novo perfil de execução no menu **Gerenciador de perfis** do console e, em seguida, vincular o perfil a um domínio ou perfil de usuário existente.
Ao criar a função, escolha a opção **Executar aplicações EMR Sem Servidor do Studio** em **Quais atividades de ML os usuários realizarão?** Em seguida, forneça o nome do seu bucket do Amazon S3 e a função de runtime de trabalho que você deseja que sua aplicação do EMR Sem Servidor use (etapa 2).
O SageMaker Role Manager adiciona automaticamente as permissões necessárias para execução e conexão com aplicativos EMR Serverless à nova função de execução. Usando o Role [Manager, você só pode atribuir uma SageMaker função]() de tempo de execução ao seu aplicativo EMR Serverless, e o aplicativo deve ser executado na mesma conta em que o Studio está implantado, usando uma função de tempo de execução criada nessa mesma conta.
1. **Etapa 4**: anexe as seguintes permissões à função de execução de SageMaker IA acessando seu aplicativo EMR Serverless.
1. Abra o console do IAM em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Escolha **Perfis** e, em seguida, pesquise seu perfil de execução pelo nome no campo **Pesquisar**. O nome do perfil é a última parte do ARN, após a última barra (/).
1. Acesse o link do seu perfil.
1. Selecione **Adicionar permissões** e, em seguida, **Criar política em linha**.
1. Na guia **JSON**, adicione as permissões do Amazon EMR Sem Servidor, permitindo o acesso e as operações do EMR com tecnologia sem servidor. Para obter detalhes sobre o documento de política, consulte *Políticas do EMR Sem Servidor* em [Políticas de referência](#studio-set-up-emr-serverless-permissions-reference). Substitua a *region*, o *accountID* e o *EMRServerlessAppRuntimeRole* passados por seus valores reais antes de copiar a lista de instruções para a política em linha de seu perfil.
**nota**
Você pode incluir quantas sequências de ARN de funções de runtime forem necessárias na permissão, separando-as por vírgulas.
1. Escolha **Próximo** e, em seguida, forneça um **nome de política**.
1. Selecione **Criar política**.
1. Repita a etapa **Criar política em linha** para adicionar outra política em linha que conceda ao perfil permissões para atualizar os domínios, perfis de usuário e espaços. Para obter detalhes sobre o documento de política `SageMakerUpdateResourcesPolicy`, consulte *Política de ações de atualização de domínio, perfil de usuário e espaço* em [Políticas de referência](#studio-set-up-emr-serverless-permissions-reference). Substitua a *region* e o *accountID* por seus valores reais antes de copiar a lista de instruções para a política em linha de seu perfil.
1. **Etapa 5**:
Associe a lista de funções de tempo de execução ao seu perfil de usuário ou domínio para que você possa navegar visualmente pela lista de funções e selecionar aquela a ser usada [ao se conectar a um aplicativo EMR Serverless](connect-emr-serverless-application.md) a partir de. JupyterLab Você pode usar o console de SageMaker IA ou o script a seguir. Posteriormente, todos os seus trabalhos do Apache Spark ou Apache Hive criados no seu caderno acessarão somente os dados e recursos permitidos pelas políticas vinculadas à função de runtime selecionada.
**Importante**
A não conclusão dessa etapa impedirá que você conecte um JupyterLab notebook a um aplicativo EMR Serverless.
------
#### [ SageMaker AI console ]
Para associar suas funções de tempo de execução ao seu perfil de usuário ou domínio usando o console de SageMaker IA:
1. Navegue até o console de SageMaker IA em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. No painel de navegação esquerdo, escolha **domínio** e selecione o domínio usando a função de execução de SageMaker IA cujas permissões você atualizou.
1.
+ Para adicionar suas funções de tempo de execução ao seu domínio: na guia **Configurações do aplicativo** da página de **detalhes do domínio**, navegue até a **JupyterLab**seção.
+ Para adicionar suas funções de tempo de execução ao seu perfil de usuário: na página de **detalhes do domínio**, escolha a guia **Perfis de usuário** e selecione o perfil de usuário usando a função de execução de SageMaker IA cujas permissões você atualizou. Na guia **Configurações do aplicativo**, navegue até a **JupyterLab**seção.
1. Escolha **Editar** e adicione suas funções de ARNs execução de tempo de execução do EMR Serverless.
1. Selecione **Enviar**.
Na próxima vez em que você se conectar a um aplicativo EMR Serverless via JupyterLab, as funções de tempo de execução devem aparecer em um menu suspenso para seleção.
------
#### [ Python script ]
Em um JupyterLab aplicativo iniciado em um espaço privado usando a função de execução de SageMaker IA cujas permissões você atualizou, execute o comando a seguir em um terminal. Substitua `domainID`, `user-profile-name`, `studio-accountID` e `EMRServerlessRuntimeExecutionRole`(s) por seus valores apropriados. Esse trecho de código atualiza as configurações do perfil do usuário para um perfil de usuário específico (`client.update_user_profile`) ou configurações de domínio (`client.update_domain`), associando especificamente as funções de runtime do EMR Sem Servidor que você criou anteriormente.
```
import botocore.session
import json
sess = botocore.session.get_session()
client = sess.create_client('sagemaker')
client.update_user_profile(
DomainId="domainID",
UserProfileName="user-profile-name",
DefaultUserSettings={
'JupyterLabAppSettings': {
'EmrSettings': {
'ExecutionRoleArns': ["arn:aws:iam::studio-accountID:role/EMRServerlessRuntimeExecutionRoleA",
"arn:aws:iam::studio-accountID:role/EMRServerlessRuntimeExecutionRoleAA"]
}
}
})
resp = client.describe_domain(DomainId="domainID")
resp['CreationTime'] = str(resp['CreationTime'])
resp['LastModifiedTime'] = str(resp['LastModifiedTime'])
print(json.dumps(resp, indent=2))
```
------
## Entre contas
Os diagramas a seguir ilustram as funções e permissões necessárias para listar e conectar-se aos aplicativos EMR Serverless do Studio quando o Studio e os aplicativos são implantados em contas diferentes. AWS
![\[O diagrama mostra as funções e permissões necessárias para listar e conectar aplicativos EMR Serverless do Studio quando o Studio e os aplicativos estão em contas diferentes. AWS\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/emr/studio-notebooks-emr-serverless-permissions-setup-crossaccount.png)
Para obter mais informações sobre como criar uma função em uma AWS conta, consulte [https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html) Criação de uma função do IAM (console).
Antes de começar:
+ Recupere o ARN da função de execução SageMaker de IA usada pelo seu espaço privado. Para obter informações sobre espaços e funções de execução na SageMaker IA, consulte[Compreendendo as permissões de espaço e os perfis de execução do domínio](execution-roles-and-spaces.md). Para obter mais informações sobre como recuperar o ARN da função de execução SageMaker da IA, consulte. [Obtenha um perfil de execução](sagemaker-roles.md#sagemaker-roles-get-execution-role)
+ Recupere o ARN do bucket do Amazon S3 que você usará para fontes de dados e armazenamento de dados de saída no [console do Amazon S3](https://console.aws.amazon.com/S3).
Para obter informações sobre como criar um bucket do Amazon S3, consulte [Criar um bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html). Para saber como encontrar um bucket pelo nome, consulte [Como acessar e listar um bucket do Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-bucket-intro.html).
Se suas aplicações do EMR Sem Servidor e o Studio forem implantados em contas da AWS separadas, você deverá configurar as permissões em ambas as contas.
### Na conta do EMR Sem Servidor
Siga estas etapas para criar os perfis e políticas necessários na conta em que sua aplicação do EMR Sem Servidor está sendo executada, também chamada de *conta confiável*:
1. **Etapa 1**: crie pelo menos um perfil de runtime de execução de trabalho para sua aplicação do EMR Sem Servidor em sua conta (o `EMRServerlessRuntimeExecutionRoleB` no diagrama de *contas cruzadas* acima). Escolha **Política de confiança personalizada** como entidade confiável. Adicione as permissões necessárias por trabalho. No mínimo, você precisa de acesso total a um bucket do Amazon S3 e acesso de criação e leitura ao catálogo de AWS Glue dados.
Para obter instruções detalhadas sobre como criar uma nova função de runtime para suas aplicações do EMR Sem Servidor, siga estas etapas:
1. Navegue até o [console do IAM](https://console.aws.amazon.com/iam).
1. No painel de navegação à esquerda, selecione **Política** e, depois, **Criar política**.
1. Adicione as permissões exigidas pela sua função de runtime, nomeie a política e escolha **Criar política**.
Para exemplos de políticas de runtime de uma função de runtime do EMR Sem Servidor, consulte [Funções de runtime de trabalho do Amazon EMR Sem Servidor](https://docs.aws.amazon.com/emr/latest/EMR-Serverless-UserGuide/security-iam-runtime-role.html).
1. No painel de navegação à esquerda, selecione **Funções** e, em seguida, **Criar perfil**.
1. Na página **Criar função**, escolha a opção **Política de confiança personalizada** como entidade confiável.
1. Cole o seguinte documento JSON na seção **Política de confiança personalizada** e escolha **Avançar**:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "emr-serverless.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Na página **Adicionar permissões**, selecione a política criada e, depois, **Avançar**.
1. Na página **Revisar**, insira um nome para a função, como `EMRServerlessAppRuntimeRoleB`, e uma descrição opcional.
1. Revisar os detalhes do perfil e selecionar **Criar perfil**.
Com esse recurso, você e seus colegas de equipe podem se conectar ao mesma aplicação, cada um usando uma função de runtime com permissões correspondentes ao seu nível individual de acesso aos dados.
**nota**
As sessões do Spark operam de forma diferente. As sessões do Spark são isoladas com base no perfil de execução usado no Studio, portanto, usuários com perfis de execução diferentes terão sessões do Spark separadas e isoladas. Além disso, se você habilitou a identidade de origem para seu domínio, haverá um isolamento adicional das sessões do Spark em diferentes identidades de origem.
1. **Etapa 2**: crie um perfil personalizado do IAM chamado `AssumableRole` com a seguinte configuração:
+ Permissões: conceda as permissões necessárias (políticas do Amazon EMR Sem Servidor) para `AssumableRole`, a fim de permitir o acesso aos recursos do EMR com tecnologia sem servidor. A função também é conhecida como *Função de acesso*.
+ Relação de confiança: configure a política de confiança para `AssumableRole`, a fim de permitir que assuma o perfil de execução (`SageMakerExecutionRole` no diagrama de contas cruzadas) da conta do Studio que requer acesso.
Ao assumir a função, o Studio pode obter acesso temporário às permissões necessárias na conta do EMR Sem Servidor.
Para obter instruções detalhadas sobre como criar uma nova `AssumableRole` em sua AWS conta EMR Serverless, siga estas etapas:
1. Navegue até o [console do IAM](https://console.aws.amazon.com/iam).
1. No painel de navegação à esquerda, selecione **Política** e, depois, **Criar política**.
1. Na guia **JSON**, adicione as permissões do Amazon EMR Sem Servidor, permitindo o acesso e as operações do EMR com tecnologia sem servidor. Para obter detalhes sobre o documento de política, consulte *Políticas do EMR Sem Servidor* em [Políticas de referência](#studio-set-up-emr-serverless-permissions-reference). Substitua a `region`, o `accountID` e o `EMRServerlessAppRuntimeRole` passados por seus valores reais antes de copiar a lista de instruções para a política em linha de seu perfil.
**nota**
O `EMRServerlessAppRuntimeRole` aqui é a função de runtime de trabalho criada na etapa 1 (o `EMRServerlessAppRuntimeRoleB` no diagrama de *contas cruzadas* acima). Você pode incluir quantas sequências de ARN de funções de runtime forem necessárias na permissão, separando-as por vírgulas.
1. Escolha **Próximo** e, em seguida, forneça um **nome de política**.
1. Selecione **Criar política**.
1. No painel de navegação à esquerda, selecione **Funções** e, em seguida, **Criar função**.
1. Na página **Criar função**, escolha a opção **Política de confiança personalizada** como entidade confiável.
1. Cole o seguinte documento JSON na seção **Política de confiança personalizada** e escolha **Avançar**:
`studio-account`Substitua pelo ID da conta do Studio e `AmazonSageMaker-ExecutionRole` pela função de execução usada pelo seu JupyterLab espaço.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Na página **Adicionar permissões**, adicione a permissão `EMRServerlessAppRuntimeRoleB` que você criou na etapa 2 e escolha **Avançar**.
1. Na página **Revisar**, insira um nome para a função, como `AssumableRole`, e uma descrição opcional.
1. Revisar os detalhes do perfil e selecionar **Criar perfil**.
Para obter mais informações sobre como criar uma função em uma AWS conta, consulte [Criação de uma função do IAM (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html).
### Na conta do Studio
Na conta em que o Studio está implantado, também chamada de *conta confiável*, atualize a função de execução de SageMaker IA acessando seus aplicativos EMR Serverless com as permissões necessárias para acessar recursos na conta confiável.
1. **Etapa 1**: Recupere o ARN da função de execução SageMaker de IA usada pelo seu espaço.
Para obter informações sobre espaços e funções de execução na SageMaker IA, consulte[Compreendendo as permissões de espaço e os perfis de execução do domínio](execution-roles-and-spaces.md).
Para obter mais informações sobre como recuperar o ARN da função de execução SageMaker da IA, consulte. [Obtenha um perfil de execução](sagemaker-roles.md#sagemaker-roles-get-execution-role)
1. **Etapa 2**: anexe as seguintes permissões à função de execução de SageMaker IA acessando seu aplicativo EMR Serverless.
1. Abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Escolha **Perfis** e, em seguida, pesquise seu perfil de execução pelo nome no campo **Pesquisar**. O nome do perfil é a última parte do ARN, após a última barra (/).
1. Acesse o link do seu perfil.
1. Selecione **Adicionar permissões** e, em seguida, **Criar política em linha**.
1. Na guia **JSON**, adicione a política em linha que concede permissões à função para atualizar os domínios, perfis de usuário e espaços. Para obter detalhes sobre o documento de política `SageMakerUpdateResourcesPolicy`, consulte *Política de ações de atualização de domínio, perfil de usuário e espaço* em [Políticas de referência](#studio-set-up-emr-serverless-permissions-reference). Substitua a `region` e o `accountID` por seus valores reais antes de copiar a lista de instruções para a política em linha de seu perfil.
1. Escolha **Próximo** e, em seguida, forneça um **nome de política**.
1. Selecione **Criar política**.
1. Repita a etapa **Criar política em linha** para adicionar outra política que conceda ao perfil de execução as permissões para assumir `AssumableRole` e, em seguida, executar as ações permitidas pela política de acesso do perfil.
Substitua `emr-account` pelo ID da conta do Amazon EMR Sem Servidor, e `AssumableRole` pelo nome da função assumível criada na conta do Amazon EMR Sem Servidor.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Sid": "AllowSTSToAssumeAssumableRole",
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::111122223333:role/AssumableRole"
}
}
```
------
1. **Etapa 3**:
Associe a lista de funções de tempo de execução ao seu domínio ou perfil de usuário para que você possa navegar visualmente pela lista de funções e selecionar aquela a ser usada [ao se conectar a um aplicativo EMR Serverless](connect-emr-serverless-application.md) a partir de. JupyterLab Você pode usar o console de SageMaker IA ou o script a seguir. Posteriormente, todos os seus trabalhos do Apache Spark ou Apache Hive criados no seu caderno acessarão somente os dados e recursos permitidos pelas políticas vinculadas à função de runtime selecionada.
**Importante**
A não conclusão dessa etapa impedirá que você conecte um JupyterLab notebook a um aplicativo EMR Serverless.
------
#### [ SageMaker AI console ]
Para associar suas funções de tempo de execução ao seu perfil de usuário ou domínio usando o console de SageMaker IA:
1. Navegue até o console de SageMaker IA em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. No painel de navegação esquerdo, escolha **domínio** e selecione o domínio usando a função de execução de SageMaker IA cujas permissões você atualizou.
1.
+ Para adicionar suas funções de tempo de execução ao seu domínio: na guia **Configurações do aplicativo** da página de **detalhes do domínio**, navegue até a **JupyterLab**seção.
+ Para adicionar suas funções de tempo de execução ao seu perfil de usuário: na página de **detalhes do domínio**, escolha a guia **Perfis de usuário** e selecione o perfil de usuário usando a função de execução de SageMaker IA cujas permissões você atualizou. Na guia **Configurações do aplicativo**, navegue até a **JupyterLab**seção.
1. Escolha **Editar** e adicione sua função assumível e as funções ARNs de execução de tempo de execução do EMR Serverless.
1. Selecione **Enviar**.
Na próxima vez em que você se conectar a um aplicativo EMR Serverless via JupyterLab, as funções de tempo de execução devem aparecer em um menu suspenso para seleção.
------
#### [ Python script ]
Em um JupyterLab aplicativo iniciado em um espaço privado usando a função de execução de SageMaker IA cujas permissões você atualizou, execute o comando a seguir em um terminal. Substitua `domainID`, `user-profile-name`, `studio-accountID` e `EMRServerlessRuntimeExecutionRole` por seus valores apropriados. Esse trecho de código atualiza as configurações do perfil do usuário para um perfil de usuário específico (`client.update_user_profile`) ou configurações de domínio (`client.update_domain`) em um domínio de SageMaker IA. Especificamente, ele define as funções de runtime para o Amazon EMR Sem Servidor, que você criou anteriormente. Também permite que o JupyterLab aplicativo assuma uma função específica do IAM (`AssumableRole`) para executar aplicativos EMR Serverless na conta do Amazon EMR.
```
import botocore.session
import json
sess = botocore.session.get_session()
client = sess.create_client('sagemaker')
client.update_user_profile(
DomainId="domainID",
UserProfileName="user-profile-name",
DefaultUserSettings={
'JupyterLabAppSettings': {
'EmrSettings': {
'AssumableRoleArns': ["arn:aws:iam::emr-accountID:role/AssumableRole"],
'ExecutionRoleArns': ["arn:aws:iam::emr-accountID:role/EMRServerlessRuntimeExecutionRoleA",
"arn:aws:iam::emr-accountID:role/AnotherRuntimeExecutionRole"]
}
}
})
resp = client.describe_user_profile(DomainId="domainID", UserProfileName=user-profile-name")
resp['CreationTime'] = str(resp['CreationTime'])
resp['LastModifiedTime'] = str(resp['LastModifiedTime'])
print(json.dumps(resp, indent=2))
```
------
## Políticas de referência
+ **Políticas do EMR Serverless**: essa política permite gerenciar aplicativos EMR Serverless, incluindo listar, criar (com as tags de SageMaker IA necessárias), iniciar, interromper, obter detalhes, excluir, acessar endpoints Livy e obter painéis de execução de tarefas. Também permite passar a função de runtime da aplicação EMR Sem Servidor necessária para o serviço.
+ `EMRServerlessListApplications`: permite a ListApplications ação em todos os recursos do EMR Serverless na região e na conta especificadas. AWS
+ `EMRServerlessPassRole`: permite transmitir as funções de tempo de execução especificadas na AWS conta fornecida, mas somente quando a função está sendo passada para `emr-serverless.amazonaws.com service` o.
+ `EMRServerlessCreateApplicationAction`: Permite que eles CreateApplication TagResource realizem ações nos recursos do EMR Serverless na região e na conta especificadas. AWS No entanto, isso exige que os recursos que estão sendo criados ou marcados tenham chaves de tag específicas (`sagemaker:domain-arn`, `sagemaker:user-profile-arn` e `sagemaker:space-arn`) presentes com valores não nulos.
+ `EMRServerlessDenyTaggingAction`: As UntagResource ações TagResource e nos recursos do EMR Serverless na região e AWS conta especificadas se os recursos não tiverem nenhuma das chaves de tag especificadas (`sagemaker:domain-arn`,`sagemaker:user-profile-arn`, e) definidas. `sagemaker:space-arn`
+ `EMRServerlessActions`: permite várias ações (`StartApplication`, `StopApplication`, `GetApplication`, `DeleteApplication`, `AccessLivyEndpoints` e `GetDashboardForJobRun`) nos recursos do EMR Sem Servidor, mas somente se os recursos tiverem as chaves de tag especificadas (`sagemaker:domain-arn`, `sagemaker:user-profile-arn` e `sagemaker:space-arn`) definidas com valores não nulos.
A política do IAM definida no documento JSON fornecido concede essas permissões, mas limita esse acesso à presença de tags de SageMaker IA específicas nos aplicativos do EMR Serverless para garantir que somente os recursos do Amazon EMR Serverless associados a um SageMaker determinado domínio de IA, perfil de usuário e espaço possam ser gerenciados.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "EMRServerlessListApplications",
"Effect": "Allow",
"Action": [
"emr-serverless:ListApplications"
],
"Resource": "arn:aws:emr-serverless:us-east-1:111122223333:/*"
},
{
"Sid": "EMRServerlessPassRole",
"Effect": "Allow",
"Action": "iam:PassRole",
"Resource": "arn:aws:iam::111122223333:role/EMRServerlessAppRuntimeRole",
"Condition": {
"StringLike": {
"iam:PassedToService": "emr-serverless.amazonaws.com"
}
}
},
{
"Sid": "EMRServerlessCreateApplicationAction",
"Effect": "Allow",
"Action": [
"emr-serverless:CreateApplication",
"emr-serverless:TagResource"
],
"Resource": "arn:aws:emr-serverless:us-east-1:111122223333:/*",
"Condition": {
"ForAllValues:StringEquals": {
"aws:TagKeys": [
"sagemaker:domain-arn",
"sagemaker:user-profile-arn",
"sagemaker:space-arn"
]
},
"Null": {
"aws:RequestTag/sagemaker:domain-arn": "false",
"aws:RequestTag/sagemaker:user-profile-arn": "false",
"aws:RequestTag/sagemaker:space-arn": "false"
}
}
},
{
"Sid": "EMRServerlessDenyTaggingAction",
"Effect": "Deny",
"Action": [
"emr-serverless:TagResource",
"emr-serverless:UntagResource"
],
"Resource": "arn:aws:emr-serverless:us-east-1:111122223333:/*",
"Condition": {
"Null": {
"aws:ResourceTag/sagemaker:domain-arn": "true",
"aws:ResourceTag/sagemaker:user-profile-arn": "true",
"aws:ResourceTag/sagemaker:space-arn": "true"
}
}
},
{
"Sid": "EMRServerlessActions",
"Effect": "Allow",
"Action": [
"emr-serverless:StartApplication",
"emr-serverless:StopApplication",
"emr-serverless:GetApplication",
"emr-serverless:DeleteApplication",
"emr-serverless:AccessLivyEndpoints",
"emr-serverless:GetDashboardForJobRun"
],
"Resource": "arn:aws:emr-serverless:us-east-1:111122223333:/applications/*",
"Condition": {
"Null": {
"aws:ResourceTag/sagemaker:domain-arn": "false",
"aws:ResourceTag/sagemaker:user-profile-arn": "false",
"aws:ResourceTag/sagemaker:space-arn": "false"
}
}
}
]
}
```
------
+ **Política de ações de atualização de domínio, perfil de usuário e espaço**: a política a seguir concede permissões para atualizar domínios, perfis de usuário e espaços de SageMaker IA na região e na AWS conta especificadas.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "SageMakerUpdateResourcesPolicy",
"Effect": "Allow",
"Action": [
"sagemaker:UpdateDomain",
"sagemaker:UpdateUserprofile",
"sagemaker:UpdateSpace"
],
"Resource": [
"arn:aws:sagemaker:us-east-1:111122223333:domain/*",
"arn:aws:sagemaker:us-east-1:111122223333:user-profile/*"
]
}
]
}
```
------
# Criar aplicações do EMR Sem Servidor a partir do Studio
Cientistas e engenheiros de dados podem criar aplicações do EMR Sem Servidor diretamente da interface de usuário do Studio. Antes de começar, certifique-se de ter configurado as permissões necessárias, conforme descrito na seção [Configure as permissões para permitir a listagem e o lançamento de aplicativos do Amazon EMR a partir do Studio SageMaker](studio-emr-serverless-permissions.md). Essas permissões concedem ao Studio a capacidade de criar, iniciar, visualizar, acessar e encerrar as aplicações.
Para criar uma aplicação do EMR Sem Servidor a partir do Studio:
1. Na interface do usuário do Studio, navegue até o painel do lado esquerdo e selecione o nó **Dados** no menu de navegação esquerdo. Em seguida, role e escolha a opção **Aplicações e clusters do Amazon EMR**. Isso abre uma página que exibe as aplicações do Amazon EMR que você pode acessar de dentro do ambiente Studio, na guia **Aplicações sem servidor**.
1. Escolha o botão **Criar aplicação sem servidor** no canto superior direito. Isso abre a página **Criar aplicação**, semelhante à visualização que você veria no [console do EMR Sem Servidor](https://console.aws.amazon.com/emrserverless) ao escolher **Usar configurações personalizadas** nas **opções de configuração da aplicação**.
1. Forneça os detalhes necessários da sua aplicação, incluindo um nome e quaisquer parâmetros configuráveis específicos que você deseja definir e, em seguida, escolha **Criar aplicação**.
![\[Forma de criação de uma aplicação do EMR Sem Servidor no Studio.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/emr/studio-notebooks-emr-serverless-create-app.png)
Todas as configurações têm valores padrão e podem ser modificadas opcionalmente. Para obter informações detalhadas sobre cada parâmetro disponível, consulte [Configurar uma aplicação](https://docs.aws.amazon.com/emr/latest/EMR-Serverless-UserGuide/application-capacity.html) no guia do usuário do EMR Sem Servidor.
**nota**
Durante o processo de criação da aplicação na interface de usuário do Studio, você tem a opção de **Criar aplicação** ou **Criar e iniciar a aplicação**. Com base na sua escolha, a aplicação entrará no estado `Creating` ou `Starting`, respectivamente.
Se você optar por criar a aplicação sem iniciá-lo em seguida, certifique-se de que a opção **Iniciar a aplicação automaticamente após o envio do trabalho** permaneça selecionada. Isso garantirá que a aplicação faça a transição automática para o estado `Starting` quando você enviar um trabalho para execução nele.
Para uma configuração mais simples, recomendamos deixar a opção **nuvem privada virtual (VPC)** definida com o valor padrão de **Sem conectividade de rede aos recursos em sua VPC** na seção **Conexões de rede**. Isso permite que a aplicação seja criado na VPC do seu domínio sem exigir nenhuma configuração de rede adicional.
Em qualquer outro caso, certifique-se de executar as seguintes etapas:
Examine seu. VPCs
Adicione rotas às suas tabelas de rotas de sub-rede privada.
Configure seus grupos de segurança conforme detalhado em [Configurar o acesso à rede para o cluster do Amazon EMR](studio-notebooks-emr-networking.md).
Isso garante a configuração de rede adequada para sua aplicação, além da opção padrão **Sem conectividade de rede**.
Para aplicações criados a partir da interface de usuário do Studio Classic, a seguinte configuração é aplicada automaticamente:
Um endpoint do Apache Livy habilitado.
A aplicação é marcado com o seguinte:
sábio: user-profile-arn
sagemaker:domain-arn
sagemaker:space-arn
Se você criar uma aplicação fora do Studio, certifique-se de habilitar manualmente o endpoint do Apache Livy e aplicar o mesmo conjunto de tags à aplicação.
Depois que a aplicação é criado, a interface do usuário do Studio Classic exibe a mensagem *A aplicação foi criado com sucesso* e o nova aplicação aparece na lista **Aplicações sem servidor**.
Para se conectar à sua aplicação do EMR Sem Servidor, consulte [Conecte-se a uma aplicação do EMR Sem Servidor a partir do Studio](connect-emr-serverless-application.md)
# Conecte-se a uma aplicação do EMR Sem Servidor a partir do Studio
Os cientistas e engenheiros de dados podem descobrir e se conectar a uma aplicação do EMR Sem Servidor diretamente da interface de usuário do Studio. Antes de começar, certifique-se de ter criado uma aplicação do EMR Sem Servidor seguindo as instruções em [Criar aplicações do EMR Sem Servidor a partir do Studio](create-emr-serverless-application.md).
Você pode conectar um aplicativo EMR Serverless a um novo JupyterLab notebook diretamente da interface do usuário do Studio ou optar por iniciar a conexão em um notebook de um aplicativo em execução. JupyterLab
**Importante**
Ao usar o Studio, você só pode descobrir e se conectar aos aplicativos EMR Serverless para JupyterLab aplicativos que são iniciados a partir de espaços privados. Certifique-se de que os aplicativos EMR Serverless estejam localizados na mesma AWS região do seu ambiente Studio. Seu JupyterLab espaço deve usar uma versão SageMaker de imagem de distribuição `1.10` ou superior.
**Para conectar um aplicativo EMR Serverless a um novo JupyterLab notebook a partir da interface do usuário do Studio:**
1. Na interface do usuário do Studio, navegue até o painel do lado esquerdo e selecione o nó **Dados** no menu de navegação esquerdo. Em seguida, role e escolha a opção **Aplicações e clusters do Amazon EMR**. Isso abre uma página que exibe as aplicações do Amazon EMR que você pode acessar de dentro do ambiente Studio, na guia **Aplicações sem servidor**.
**nota**
Se você ou seu administrador tiverem configurado as permissões para permitir o acesso entre contas às aplicações do EMR Sem Servidor, você poderá visualizar uma lista consolidada de aplicações em todas as contas às quais você concedeu acesso ao Studio.
1. Selecione uma aplicação do EMR Sem Servidor que você deseja conectar a um novo caderno e, em seguida, escolha **Anexar ao caderno**. Isso abre uma janela modal exibindo a lista de seus JupyterLab espaços.
1.
+ Selecione o espaço privado a partir do qual você deseja iniciar um JupyterLab aplicativo e escolha **Abrir caderno**. Isso inicia um JupyterLab aplicativo do espaço escolhido e abre um novo caderno.
+ Como alternativa, você pode criar um novo espaço privado escolhendo o botão **Criar novo espaço** na parte superior da janela modal. Insira um nome para o seu espaço e escolha **Criar espaço e abrir o caderno**. Isso cria um espaço privado com o tipo de instância padrão e a imagem SageMaker de distribuição mais recente disponível, inicia um JupyterLab aplicativo e abre um novo notebook.
1. Escolha o nome da função de runtime do IAM que sua aplicação do EMR Sem Servidor pode assumir para a execução do trabalho. Após a seleção, um comando de conexão preenche a primeira célula do caderno e inicia a conexão com a aplicação do EMR Sem Servidor.
**Importante**
Para conectar com êxito um JupyterLab notebook a um aplicativo EMR Serverless, você deve primeiro associar a lista de funções de tempo de execução ao seu domínio ou perfil de usuário, conforme descrito em. [Configure as permissões para permitir a listagem e o lançamento de aplicativos do Amazon EMR a partir do Studio SageMaker](studio-emr-serverless-permissions.md) A falha na conclusão dessa etapa impedirá que você estabeleça a conexão.
Quando a conexão for bem-sucedida, uma mensagem confirmará a conexão, iniciará sua aplicação do EMR Sem Servidor e iniciará sua sessão do Spark.
**nota**
Quando você se conecta a uma aplicação do EMR Sem Servidor, seu status muda de `Stopped` ou `Created` para `Started`.
**Como alternativa, você pode se conectar a um cluster a partir de um JupyterLab notebook.**
1. Escolha o botão **Cluster** na parte superior do seu caderno. Isso abre uma janela modal listando as aplicações do EMR Sem Servidor que você pode acessar. Você pode ver as aplicações na guia **Aplicações sem servidor**.
1. Selecione a aplicação ao qual deseja conectar e escolha **Conectar**.
1. O EMR Sem Servidor é compatível com perfis de runtime do IAM que foram pré-carregados ao definir as permissões necessárias, conforme descrito em [Configure as permissões para permitir a listagem e o lançamento de aplicativos do Amazon EMR a partir do Studio SageMaker](studio-emr-serverless-permissions.md). A falha na conclusão dessa etapa impedirá que você estabeleça a conexão.
Você pode selecionar seu perfil no menu suspenso de **perfil de execução do Amazon EMR**. Quando você se conecta a um EMR Sem Servidor, o Studio adiciona um bloco de código a uma célula ativa do seu caderno para estabelecer a conexão.
1. Uma célula ativa é preenchida e executada. Essa célula contém o comando mágico de conexão para conectar seu caderno à aplicação.
Quando a conexão for bem-sucedida, uma mensagem confirmará a conexão e o início da aplicação do Spark. Você pode começar a enviar seus trabalhos de processamento de dados para sua aplicação do EMR Sem Servidor.
# Pare ou exclua uma aplicação do EMR Sem Servidor a partir da interface do Studio
Você pode interromper (fazer a transição para o estado `Stopped`) ou excluir (fazer a transição para o estado `Deleted`) uma aplicação do EMR Sem Servidor da lista de aplicações na interface de usuário do Studio.
**Para interromper ou excluir uma aplicação, navegue até a lista de aplicações do EMR Sem Servidor disponíveis.**
1. Na interface do usuário do Studio, navegue até o painel do lado esquerdo e selecione o nó **Dados** no menu de navegação esquerdo. Em seguida, role e escolha a opção **Aplicações e clusters do Amazon EMR**. Isso abre uma página que exibe as aplicações do Amazon EMR que você pode acessar de dentro do ambiente Studio, na guia **Aplicações sem servidor**.
1. Selecione o nome da aplicação que você deseja interromper ou excluir e, em seguida, escolha o botão **Parar** ou **Excluir** correspondente.
1. Uma mensagem de confirmação informa que qualquer trabalho pendente será perdido permanentemente.
# Preparação de dados usando o Amazon EMR
**Importante**
O Amazon SageMaker Studio e o Amazon SageMaker Studio Classic são dois dos ambientes de aprendizado de máquina que você pode usar para interagir com a SageMaker IA.
Se seu domínio foi criado depois de 30 de novembro de 2023, o Studio é sua experiência padrão.
Se seu domínio foi criado antes de 30 de novembro de 2023, o Amazon SageMaker Studio Classic é sua experiência padrão. Para usar o Studio se o Amazon SageMaker Studio Classic for sua experiência padrão, consulte[Migração do Amazon SageMaker Studio Classic](studio-updated-migrate.md).
Quando você migra do Amazon SageMaker Studio Classic para o Amazon SageMaker Studio, não há perda na disponibilidade dos recursos. O Studio Classic também existe como um aplicativo no Amazon SageMaker Studio para ajudá-lo a executar seus fluxos de trabalho legados de aprendizado de máquina.
O Amazon SageMaker Studio e o Studio Classic vêm com integração integrada com o [Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-what-is-emr.html). [https://aws.amazon.com/emr/features/hive](https://aws.amazon.com/emr/features/hive) Com um único clique, eles podem acessar a interface de usuário do Spark para monitorar o status e as métricas de seus trabalhos do Spark sem sair do caderno.
Os administradores podem criar [modelos do CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html) que definam os clusters do Amazon EMR. Depois, eles podem disponibilizar esses modelos de cluster no [AWS Service Catalog](https://docs.aws.amazon.com/servicecatalog/latest/userguide/end-user-console.html) para os usuários do Studio e do Studio Classic iniciarem. Os cientistas de dados podem, então, escolher um modelo predefinido para provisionar automaticamente um cluster do Amazon EMR diretamente do ambiente do Studio. Os administradores podem parametrizar ainda mais os modelos para permitir que os usuários escolham aspectos do cluster dentro de valores predefinidos. Por exemplo, os usuários podem querer especificar o número de nós centrais ou selecionar o tipo de instância de um nó no menu suspenso.
Usando CloudFormation, os administradores podem controlar a configuração organizacional, de segurança e de rede dos clusters do Amazon EMR. Depois, os cientistas e engenheiros de dados podem personalizar esses modelos para suas workloads a fim de criar clusters sob demanda do Amazon EMR diretamente do Studio e do Studio Classic sem definir configurações complexas. Os usuários podem encerrar os clusters do Amazon EMR após o uso.
+ **Se você for administrador**:
Certifique-se de ter habilitado a comunicação entre o Studio ou o Studio Classic e os clusters do Amazon EMR. Para obter instruções, consulte a próxima seção [Configurar o acesso à rede para o cluster do Amazon EMR](studio-notebooks-emr-networking.md). Depois que a comunicação estiver ativada, você poderá:
+ [Configurar CloudFormation modelos do Amazon EMR no Service Catalog](studio-notebooks-set-up-emr-templates.md)
+ [Configurar a listagem de clusters do Amazon EMR](studio-notebooks-configure-discoverability-emr-cluster.md)
+ **Se você é cientista de dados ou engenheiro de dados**, você pode:
+ [Inicializar um cluster do Amazon EMR no Studio ou Studio Classic](studio-notebooks-launch-emr-cluster-from-template.md)
+ [Listar clusters do Amazon EMR no Studio ou no Studio Classic](discover-emr-clusters.md)
+ [Conecte-se a um cluster do Amazon EMR a partir do SageMaker Studio ou do Studio Classic](connect-emr-clusters.md)
+ [Encerrar um cluster do Amazon EMR no Studio ou Studio Classic](terminate-emr-clusters.md)
+ [Acesse a interface de usuário do Spark no Studio ou no Studio Classic](studio-notebooks-access-spark-ui.md)
**Topics**
+ [Início rápido: crie um domínio de sandbox de SageMaker IA para lançar clusters do Amazon EMR no Studio](studio-notebooks-emr-cluster-quickstart.md)
+ [Guia de administrador](studio-emr-admin-guide.md)
+ [Guia do usuário](studio-emr-user-guide.md)
+ [Blogs e guias técnicos](studio-notebooks-emr-resources.md)
+ [Solução de problemas](studio-notebooks-emr-troubleshooting.md)
# Início rápido: crie um domínio de sandbox de SageMaker IA para lançar clusters do Amazon EMR no Studio
Esta seção mostra a configuração rápida de um ambiente de teste completo no Amazon SageMaker Studio. Você criará um novo domínio do Studio que permite que os usuários iniciem novos clusters do Amazon EMR diretamente do Studio. As etapas fornecem um exemplo de caderno que você pode conectar a um cluster do Amazon EMR para começar a executar workloads Spark. Usando esse notebook, você criará um Sistema de Geração Aumentada de Recuperação (RAG) usando o processamento distribuído e o banco de dados vetoriais do Amazon EMR Spark. OpenSearch
**nota**
Para começar, faça login no AWS Management Console usando uma conta de usuário AWS Identity and Access Management (IAM) com permissões de administrador. Para obter informações sobre como se inscrever em uma conta da AWS e criar um usuário com acesso administrativo, consulte [Pré-requisitos completos do Amazon SageMaker AI](gs-set-up.md).
**Para configurar seu ambiente de teste do Studio e começar a executar trabalhos Spark:**
+ [Etapa 1: criar um domínio de SageMaker IA para lançar clusters do Amazon EMR no Studio](#studio-notebooks-emr-cluster-quickstart-setup)
+ [Etapa 2: inicialize um novo cluster do Amazon EMR pela interface do Studio](#studio-notebooks-emr-cluster-quickstart-launch)
+ [Etapa 3: Conectar um JupyterLab notebook ao cluster do Amazon EMR](#studio-notebooks-emr-cluster-quickstart-connect)
+ [Etapa 4: limpe sua CloudFormation pilha](#studio-notebooks-emr-cluster-quickstart-clean-stack)
## Etapa 1: criar um domínio de SageMaker IA para lançar clusters do Amazon EMR no Studio
Nas etapas a seguir, você aplica uma CloudFormation pilha para criar automaticamente um novo domínio de SageMaker IA. A pilha também cria um perfil de usuário e configura o ambiente e as permissões necessários. O domínio SageMaker AI está configurado para permitir que você inicie diretamente clusters do Amazon EMR a partir do Studio. Neste exemplo, os clusters do Amazon EMR são criados na mesma AWS conta da SageMaker IA sem autenticação. [Você pode encontrar CloudFormation pilhas adicionais que suportam vários métodos de autenticação, como Kerberos, no repositório getting\$1started.](https://github.com/aws-samples/sagemaker-studio-emr/tree/main/cloudformation/getting_started) GitHub
**nota**
SageMaker A IA permite 5 domínios do Studio por AWS conta e Região da AWS por padrão. Certifique-se de que sua conta não tenha mais do que 4 domínios em sua região antes de criar sua pilha.
**Siga estas etapas para configurar um domínio de SageMaker IA para lançar clusters do Amazon EMR a partir do Studio.**
1. Baixe o arquivo bruto desse [CloudFormation modelo](https://github.com/aws-samples/sagemaker-studio-foundation-models/blob/main/workshop-artifacts/cfn/workshop-cfn.yaml) do `sagemaker-studio-emr` GitHub repositório.
1. Vá para o CloudFormation console: [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/)
1. Escolha **Criar pilha** e selecione **Com novos recursos (padrão)** no menu suspenso.
1. Na **Etapa 1**:
1. Na seção **Preparar modelo**, selecione **Escolher um modelo existente**.
1. Na seção **Especificar modelo** escolha **Fazer carregar um arquivo de modelo**.
1. Faça o upload do CloudFormation modelo baixado e escolha **Avançar**.
1. Na **Etapa 2**, insira o **nome da pilha** e escolha **SageMakerDomainName****Avançar**.
1. Na **Etapa 3**, mantenha todos os valores padrão e escolha **Avançar**.
1. Na **Etapa 4**, marque a caixa para confirmar a criação do recurso e escolha **Criar pilha**. Isso cria um domínio do Studio em sua conta e região.
## Etapa 2: inicialize um novo cluster do Amazon EMR pela interface do Studio
Nas etapas a seguir, você cria um novo cluster do Amazon EMR a partir da interface de usuário do Studio.
1. Acesse o console de SageMaker IA em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/)e escolha **Domínios** no menu à esquerda.
1. Clique no seu nome de domínio **Generative AIDomain** para abrir a página de **detalhes do domínio**.
1. Execute o Studio a partir do perfil de usuário `genai-user`.
1. No painel de navegação à esquerda, acesse **Dados** e, depois, **Clusters do Amazon EMR**.
1. Na página de clusters do Amazon EMR, escolha **Criar**. **Selecione o modelo **SageMaker Studio Domain No Auth EMR** criado pela CloudFormation pilha e escolha Avançar.**
1. Insira um nome para o novo cluster do Amazon EMR. Opcionalmente, atualize outros parâmetros, como o tipo de instância dos nós centrais e nós principais, o tempo limite de inatividade ou o número de nós centrais.
1. Escolha **Criar recurso** para iniciar o novo cluster do Amazon EMR.
Depois de criar o cluster do Amazon EMR, acompanhe o status na página **Clusters do EMR**. Quando o status muda para `Running/Waiting`, seu cluster do Amazon EMR está pronto para uso no Studio.
## Etapa 3: Conectar um JupyterLab notebook ao cluster do Amazon EMR
Nas etapas a seguir, você conecta um notebook JupyterLab ao seu cluster do Amazon EMR em execução. Neste exemplo, você importa um notebook que permite criar um sistema Retrieval Augmented Generation (RAG) usando o processamento distribuído e o banco de dados vetoriais do Amazon EMR Spark. OpenSearch
1.
**Lançamento JupyterLab**
No Studio, inicie o JupyterLab aplicativo.
1.
**Crie um espaço privado.**
Se você não criou um espaço para seu JupyterLab aplicativo, escolha **Criar um JupyterLab espaço**. Insira um nome para o espaço e mantenha-o como **Privado**. Deixe todas as outras configurações no modo padrão e escolha **Criar espaço**.
Caso contrário, execute seu JupyterLab espaço para iniciar um JupyterLab aplicativo.
1.
**Implemente seu LLM e modelos de incorporação para inferência**
+ No menu superior, escolha **Arquivo**, **Novo** e, depois, **Terminal**.
+ Na janela do terminal, execute o seguinte comando:
```
wget --no-check-certificate https://raw.githubusercontent.com/aws-samples/sagemaker-studio-foundation-models/main/lab-00-setup/Lab_0_Warm_Up_Deploy_EmbeddingModel_Llama2_on_Nvidia.ipynb
mkdir AWSGuides
cd AWSGuides
wget --no-check-certificate https://raw.githubusercontent.com/aws-samples/sagemaker-studio-foundation-models/main/lab-03-rag/AWSGuides/AmazonSageMakerDeveloperGuide.pdf
wget --no-check-certificate https://raw.githubusercontent.com/aws-samples/sagemaker-studio-foundation-models/main/lab-03-rag/AWSGuides/EC2DeveloperGuide.pdf
wget --no-check-certificate https://raw.githubusercontent.com/aws-samples/sagemaker-studio-foundation-models/main/lab-03-rag/AWSGuides/S3DeveloperGuide.pdf
```
Isso recupera o caderno `Lab_0_Warm_Up_Deploy_EmbeddingModel_Llama2_on_Nvidia.ipynb` em seu diretório local e baixa três arquivos PDF em uma pasta `AWSGuides` local.
+ Abra `lab-00-setup/Lab_0_Warm_Up_Deploy_EmbeddingModel_Llama2_on_Nvidia.ipynb`, mantenha o kernel `Python 3 (ipykernel)` e execute cada célula.
**Atenção**
Na seção **Contrato de licença do Llama 2**, não se esqueça de aceitar o EULA do Llama2 antes de continuar.
O caderno implanta dois modelos, `Llama 2` e `all-MiniLM-L6-v2 Models`, no `ml.g5.2xlarge` para inferência.
A implantação dos modelos e a criação dos endpoints podem levar algum tempo.
1.
**Abra seu caderno principal**
Em JupyterLab, abra seu terminal e execute o seguinte comando.
```
cd ..
wget --no-check-certificate https://raw.githubusercontent.com/aws-samples/sagemaker-studio-foundation-models/main/lab-03-rag/Lab_3_RAG_on_SageMaker_Studio_using_EMR.ipynb
```
Você deve ver o `Lab_3_RAG_on_SageMaker_Studio_using_EMR.ipynb` caderno adicional no painel esquerdo do JupyterLab.
1.
**Escolha um kernel `PySpark`**
Abra seu caderno `Lab_3_RAG_on_SageMaker_Studio_using_EMR.ipynb` e verifique se você está usando o kernel `SparkMagic PySpark`. Você pode alternar o kernel no canto superior direito do caderno. Escolha o nome do kernel atual para abrir um modal de seleção do kernel e, em seguida, escolha `SparkMagic PySpark`.
1.
**Conecte seu caderno com o cluster**
1. Escolha **Cluster** na parte superior direita do caderno. Essa ação abre uma janela modal que lista todos os clusters em execução que você tem permissão para acessar.
1. Agora selecione seu cluster e escolha **Conectar**. Uma nova janela modal de seleção de tipo de credencial é aberta.
1. Escolha **Sem credenciais** e, em seguida, selecione **Conectar**.
![\[Modal mostrando a seleção de credenciais JupyterLab do Amazon EMR para notebooks.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/emr/studio-notebooks-emr-credential-selection.png)
1. Uma célula do caderno é preenchida e executada automaticamente. A célula do caderno carrega a extensão `sagemaker_studio_analytics_extension.magics`, que fornece funcionalidade para se conectar ao cluster do Amazon EMR. Em seguida, ela usa o comando mágico `%sm_analytics` para iniciar a conexão com seu cluster do Amazon EMR e com a aplicação Spark.
**nota**
Certifique-se de que a cadeia de conexão do seu cluster do Amazon EMR tenha um tipo de autenticação definido como `None`. Isso é ilustrado pelo valor `--auth-type None` no exemplo a seguir. Se necessário, você pode modificar o campo.
```
%load_ext sagemaker_studio_analytics_extension.magics
%sm_analytics emr connect --verify-certificate False --cluster-id your-cluster-id --auth-type None --language python
```
1. Depois de estabelecer a conexão com sucesso, a mensagem de saída da célula de conexão deve exibir seus detalhes `SparkSession`, incluindo o ID do cluster, o ID da aplicação `YARN` e um link para a interface de usuário Spark para monitorar seus trabalhos Spark.
Você está pronto para usar o caderno `Lab_3_RAG_on_SageMaker_Studio_using_EMR.ipynb`. Este exemplo de notebook executa PySpark cargas de trabalho distribuídas para criar um sistema RAG usando e. LangChain OpenSearch
## Etapa 4: limpe sua CloudFormation pilha
Depois de terminar, certifique-se de encerrar seus dois endpoints e excluir sua pilha CloudFormation para evitar cobranças contínuas. A exclusão da pilha limpa todos os recursos que foram provisionados pela pilha.
**Para excluir sua CloudFormation pilha quando você terminar de usá-la**
1. Vá para o CloudFormation console: [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/)
1. Selecione a pilha que deseja excluir. Você pode procurá-la pelo nome ou encontrá-la na lista de pilhas.
1. Clique no botão **Excluir** para finalizar a exclusão da pilha e, depois, em **Excluir** novamente para reconhecer que isso excluirá todos os recursos criados pela pilha.
Aguarde a conclusão da exclusão da pilha. Isso pode levar alguns minutos. CloudFormation limpa automaticamente todos os recursos definidos no modelo de pilha.
1. Verifique se todos os recursos criados pela pilha foram excluídos. Por exemplo, verifique se há algum cluster restante do Amazon EMR.
**Para remover os endpoints da API de um modelo**
1. Vá para o console de SageMaker IA: [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. No painel de navegação à esquerda, selecione **Inferência** e, em seguida, **Endpoints**.
1. Selecione o endpoint `hf-allminil6v2-embedding-ep` e escolha **Excluir** na lista suspensa **Ações**. Repita a etapa para o endpoint `meta-llama2-7b-chat-tg-ep`.
# Guia de administrador
Esta seção fornece pré-requisitos e instruções de rede para permitir a comunicação entre o Studio ou o Studio Classic e os clusters do Amazon EMR. Ele abrange diferentes cenários de implantação: quando o Studio e o Amazon EMR são provisionados na Amazon privada VPCs sem acesso público à Internet, bem como quando precisam se comunicar pela Internet.
Mostra como os administradores podem usar o AWS Service Catalog para disponibilizar CloudFormation modelos para o Studio, permitindo que cientistas de dados descubram e autoprovisionem clusters do Amazon EMR diretamente do Studio. Isso envolve a criação de um portfólio do Service Catalog, a concessão das permissões necessárias, a referência aos modelos do Amazon EMR e a parametrização deles para permitir personalizações durante a criação do cluster.
Por fim, ela fornece orientação sobre como configurar a capacidade de descoberta de clusters existentes do Amazon EMR que estão em execução a partir do Studio e do Studio Classic, abrangendo cenários de acesso de conta única e acesso entre contas, juntamente com as permissões necessárias do IAM.
**Topics**
+ [Configurar CloudFormation modelos do Amazon EMR no Service Catalog](studio-notebooks-set-up-emr-templates.md)
+ [Configurar a listagem de clusters do Amazon EMR](studio-notebooks-configure-discoverability-emr-cluster.md)
+ [Configurar perfis de runtime do IAM para acesso ao cluster do Amazon EMR no Studio](studio-notebooks-emr-cluster-rbac.md)
+ [Políticas de referência](studio-set-up-emr-permissions-reference.md)
# Configurar CloudFormation modelos do Amazon EMR no Service Catalog
[Este tópico pressupõe que os administradores estejam familiarizados com [CloudFormation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/Welcome.html)[os portfólios e produtos](https://docs.aws.amazon.com/servicecatalog/latest/adminguide/getstarted-portfolio.html) do Amazon EMR. AWS Service Catalog](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-gs.html)
Para simplificar a criação de clusters do Amazon EMR a partir do Studio, os administradores podem registrar um [ CloudFormation modelo do Amazon EMR](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-elasticmapreduce-cluster.html) como um produto em um portfólio. [AWS Service Catalog](https://docs.aws.amazon.com/servicecatalog/latest/adminguide/introduction.html) Para disponibilizar o modelo aos cientistas de dados, eles devem associar o portfólio à função de execução de SageMaker IA usada no Studio ou no Studio Classic. Por fim, para permitir que os usuários descubram modelos, provisionem clusters e se conectem aos clusters do Amazon EMR no Studio ou Studio Classic, os administradores precisam definir as permissões de acesso apropriadas.
Os CloudFormation modelos do Amazon EMR podem permitir que os usuários finais personalizem vários aspectos do cluster. Por exemplo, o administrador pode definir uma lista de tipos de instância permitidos que os usuários podem escolher ao criar um cluster.
As instruções a seguir usam end-to-end [CloudFormation pilhas](https://github.com/aws-samples/sagemaker-studio-emr/tree/main/cloudformation/getting_started) para configurar um domínio Studio ou Studio Classic, um perfil de usuário, um portfólio do Service Catalog e preencher um modelo de lançamento do Amazon EMR. As etapas a seguir destacam as configurações específicas que os administradores devem aplicar em sua end-to-end pilha para permitir que o Studio ou o Studio Classic acessem os produtos do Service Catalog e provisionem clusters do Amazon EMR.
**nota**
O GitHub repositório [aws-samples/ sagemaker-studio-emr](https://github.com/aws-samples/sagemaker-studio-emr/tree/main/cloudformation/getting_started) contém exemplos de end-to-end CloudFormation pilhas que implantam as funções, a rede, o domínio, o perfil de SageMaker usuário, o portfólio do Service Catalog necessários e adicionam um modelo de lançamento do Amazon EMR. CloudFormation Os modelos oferecem diferentes opções de autenticação entre o Studio ou o Studio Classic e o cluster do Amazon EMR. Nesses modelos de exemplo, a CloudFormation pilha principal passa os parâmetros de SageMaker AI VPC, grupo de segurança e sub-rede para o modelo de cluster do Amazon EMR.
O repositório [sagemaker-studio-emr/cloudformation/emr\$1servicecatalog\$1templates](https://github.com/aws-samples/sagemaker-studio-emr/tree/main/cloudformation/emr_servicecatalog_templates) contém vários exemplos de modelos de lançamento do Amazon EMR, incluindo opções para implantações de conta única e entre contas. CloudFormation
Consulte [Conecte-se a um cluster do Amazon EMR a partir do SageMaker Studio ou do Studio Classic](connect-emr-clusters.md) para obter detalhes sobre os métodos de autenticação que você pode usar para se conectar a um cluster do Amazon EMR.
Para permitir que cientistas de dados descubram CloudFormation modelos do Amazon EMR e provisionem clusters do Studio ou do Studio Classic, siga estas etapas.
## Etapa 0: verifique sua rede e prepare sua CloudFormation pilha
Antes de começar:
+ Verifique se você analisou os requisitos de rede e segurança em [Configurar o acesso à rede para o cluster do Amazon EMR](studio-notebooks-emr-networking.md).
+ Você deve ter uma end-to-end CloudFormation pilha existente que suporte o método de autenticação de sua escolha. Você pode encontrar exemplos desses CloudFormation modelos no repositório [sagemaker-studio-emr GitHub aws-samples/](https://github.com/aws-samples/sagemaker-studio-emr/tree/main/cloudformation/getting_started). As etapas a seguir destacam as configurações específicas em sua end-to-end pilha para permitir o uso de modelos do Amazon EMR no Studio ou no Studio Classic.
## Etapa 1: associar seu portfólio do Service Catalog à SageMaker IA
**Em seu portfólio do Service Catalog**, associe seu ID de portfólio à função de execução de SageMaker IA que acessa seu cluster.
Para fazer isso, adicione a seção a seguir (aqui, no formato YAML) à sua pilha. Isso concede à função de execução de SageMaker IA acesso ao portfólio especificado do Service Catalog contendo produtos como os modelos do Amazon EMR. Ele permite que as funções assumidas pela SageMaker IA lancem esses produtos.
*SageMakerStudioEMRProductPortfolio.ID*Substitua *SageMakerExecutionRole.Arn* e por seus valores reais.
```
SageMakerStudioEMRProductPortfolioPrincipalAssociation:
Type: AWS::ServiceCatalog::PortfolioPrincipalAssociation
Properties:
PrincipalARN: SageMakerExecutionRole.Arn
PortfolioId: SageMakerStudioEMRProductPortfolio.ID
PrincipalType: IAM
```
Para obter detalhes sobre o conjunto necessário de permissões do IAM, consulte a seção de [permissões](#studio-emr-permissions).
## Etapa 2: referencie um modelo do Amazon EMR em um produto do Service Catalog
**Em um produto do Service Catalog do seu portfólio**, faça referência a um recurso de modelo do Amazon EMR e garanta sua visibilidade no Studio ou no Studio Classic.
Para fazer isso, faça referência ao recurso do modelo do Amazon EMR na definição de produto do Service Catalog e, em seguida, adicione o conjunto `"sagemaker:studio-visibility:emr"` de chave de tag ao valor `"true"` (veja o exemplo em formato YAML).
Na definição do produto Service Catalog, o CloudFormation modelo do cluster é referenciado via URL. A tag adicional definida como “true” garante a visibilidade dos modelos do Amazon EMR no Studio ou no Studio Classic.
**nota**
O modelo do Amazon EMR referenciado pelo URL fornecido no exemplo não impõe nenhum requisito de autenticação quando inicializado. A opção é destinada a fins de demonstração e aprendizado. Não é recomendada em um ambiente de produção.
```
SMStudioEMRNoAuthProduct:
Type: AWS::ServiceCatalog::CloudFormationProduct
Properties:
Owner: AWS
Name: SageMaker Studio Domain No Auth EMR
ProvisioningArtifactParameters:
- Name: SageMaker Studio Domain No Auth EMR
Description: Provisions a SageMaker domain and No Auth EMR Cluster
Info:
LoadTemplateFromURL: Link to your CloudFormation template. For example, https://aws-blogs-artifacts-public.s3.amazonaws.com/artifacts/astra-m4-sagemaker/end-to-end/CFN-EMR-NoStudioNoAuthTemplate-v3.yaml
Tags:
- Key: "sagemaker:studio-visibility:emr"
Value: "true"
```
## Etapa 3: Parametrizar o modelo do Amazon EMR CloudFormation
**O CloudFormation modelo usado para definir o cluster do Amazon EMR dentro do produto Service Catalog** permite que os administradores especifiquem parâmetros configuráveis. Os administradores podem definir valores `Default` e intervalos `AllowedValues` para esses parâmetros na seção `Parameters` do modelo. Durante o processo de inicialização do cluster, os cientistas de dados podem fornecer entradas personalizadas ou fazer seleções a partir dessas opções predefinidas para personalizar certos aspectos do cluster do Amazon EMR.
O exemplo a seguir ilustra parâmetros de entrada adicionais que os administradores podem definir ao criar um modelo do Amazon EMR.
```
"Parameters": {
"EmrClusterName": {
"Type": "String",
"Description": "EMR cluster Name."
},
"MasterInstanceType": {
"Type": "String",
"Description": "Instance type of the EMR master node.",
"Default": "m5.xlarge",
"AllowedValues": [
"m5.xlarge",
"m5.2xlarge",
"m5.4xlarge"
]
},
"CoreInstanceType": {
"Type": "String",
"Description": "Instance type of the EMR core nodes.",
"Default": "m5.xlarge",
"AllowedValues": [
"m5.xlarge",
"m5.2xlarge",
"m5.4xlarge",
"m3.medium",
"m3.large",
"m3.xlarge",
"m3.2xlarge"
]
},
"CoreInstanceCount": {
"Type": "String",
"Description": "Number of core instances in the EMR cluster.",
"Default": "2",
"AllowedValues": [
"2",
"5",
"10"
]
},
"EmrReleaseVersion": {
"Type": "String",
"Description": "The release version of EMR to launch.",
"Default": "emr-5.33.1",
"AllowedValues": [
"emr-5.33.1",
"emr-6.4.0"
]
}
}
```
Depois que os administradores disponibilizarem os modelos do Amazon CloudFormation EMR no Studio, os cientistas de dados poderão usá-los para autoprovisionar clusters do Amazon EMR. A seção `Parameters` definida no modelo se traduz em campos de entrada no formulário de criação de cluster no Studio ou no Studio Classic. Para cada parâmetro, os cientistas de dados podem inserir um valor personalizado no campo de inserção ou selecionar entre as opções predefinidas listadas em um menu suspenso, que corresponde ao `AllowedValues` especificado no modelo.
A ilustração a seguir mostra o formulário dinâmico montado a partir de um modelo do CloudFormation Amazon EMR para criar um cluster do Amazon EMR no Studio ou no Studio Classic.
![\[Ilustração de um formulário dinâmico montado a partir de um modelo do CloudFormation Amazon EMR para criar um cluster do Amazon EMR a partir do Studio ou do Studio Classic.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/emr/studio-notebooks-emr-cluster-creation.png)
Visite [Inicializar um cluster do Amazon EMR no Studio ou Studio Classic](studio-notebooks-launch-emr-cluster-from-template.md) para saber como iniciar um cluster no Studio ou Studio Classic usando esses modelos do Amazon EMR.
## Etapa 4: configure as permissões para permitir a listagem e a inicialização de clusters do Amazon EMR a partir do Studio
Por fim, anexe as permissões necessárias do IAM para permitir a listagem dos clusters existentes do Amazon EMR em execução e o provisionamento automático de novos clusters do Studio ou do Studio Classic.
A função à qual você deve adicionar essas políticas depende se o Studio ou o Studio Classic e o Amazon EMR estão implantados na mesma conta (escolha *Conta única*) ou em contas diferentes (escolha *Contas cruzadas*).
**Importante**
Você só pode descobrir e se conectar aos clusters do Amazon EMR JupyterLab e aos aplicativos do Studio Classic que são lançados a partir de espaços privados. Certifique-se de que os clusters do Amazon EMR estejam localizados na mesma AWS região do seu ambiente Studio.
### Conta única
Se seus clusters do Amazon EMR e o Studio ou o Studio Classic estiverem implantados na mesma AWS conta, anexe as seguintes permissões à função de execução da SageMaker IA que acessa seu cluster.
1. **Etapa 1**: Recupere o ARN da função de execução SageMaker de IA usada pelo seu espaço privado.
Para obter informações sobre espaços e funções de execução na SageMaker IA, consulte[Compreendendo as permissões de espaço e os perfis de execução do domínio](execution-roles-and-spaces.md).
Para obter mais informações sobre como recuperar o ARN da função de execução SageMaker da IA, consulte. [Obtenha um perfil de execução](sagemaker-roles.md#sagemaker-roles-get-execution-role)
1. **Etapa 2**: anexe as seguintes permissões à função de execução de SageMaker IA acessando seus clusters do Amazon EMR.
1. Navegue até o [console do IAM](https://console.aws.amazon.com/iam).
1. Escolha **Perfis** e, em seguida, pesquise seu perfil de execução pelo nome no campo **Pesquisar**. O nome do perfil é a última parte do ARN, após a última barra (/).
1. Acesse o link do seu perfil.
1. Selecione **Adicionar permissões** e, em seguida, **Criar política em linha**.
1. Na guia **JSON**, adicione as permissões do Amazon EMR que permitem o acesso e as operações do Amazon EMR. Para obter detalhes sobre o documento de política, consulte *Listar políticas do Amazon EMR* em [Políticas de referência](studio-set-up-emr-permissions-reference.md). Substitua a `region` e o `accountID` por seus valores reais antes de copiar a lista de instruções para a política em linha de seu perfil.
1. Escolha **Próximo** e, em seguida, forneça um **nome de política**.
1. Selecione **Criar política**.
1. Repita a etapa **Criar política em linha** para adicionar outra política que concede ao perfil de execução as permissões para provisionar novos clusters do Amazon EMR usando modelos do CloudFormation . Para obter detalhes sobre o documento de política, consulte *Criar EMRclusters políticas da Amazon* em[Políticas de referência](studio-set-up-emr-permissions-reference.md). Substitua a `region` e o `accountID` por seus valores reais antes de copiar a lista de instruções para a política em linha de seu perfil.
**nota**
Os usuários da conectividade de controle de acesso baseado em funções (RBAC) com os clusters do Amazon EMR também devem consultar [Configure a autenticação da função de runtime quando o cluster do Amazon EMR e o Studio estiverem na mesma conta](studio-notebooks-emr-cluster-rbac.md#studio-notebooks-emr-cluster-iam-same).
### Entre contas
Antes de começar, recupere o ARN da função de execução SageMaker de IA usada pelo seu espaço privado.
Para obter informações sobre espaços e funções de execução na SageMaker IA, consulte[Compreendendo as permissões de espaço e os perfis de execução do domínio](execution-roles-and-spaces.md).
Para obter mais informações sobre como recuperar o ARN da função de execução SageMaker da IA, consulte. [Obtenha um perfil de execução](sagemaker-roles.md#sagemaker-roles-get-execution-role)
Se seus clusters do Amazon EMR e o Studio ou o Studio Classic forem implantados em AWS contas separadas, você configura as permissões em ambas as contas.
**nota**
Os usuários da conectividade de controle de acesso baseado em funções (RBAC) com os clusters do Amazon EMR também devem consultar [Configure a autenticação da função de runtime quando o cluster do Studio estiver em contas diferentes](studio-notebooks-emr-cluster-rbac.md#studio-notebooks-emr-cluster-iam-diff).
#### Na conta de cluster do Amazon EMR
Siga estas etapas para criar as funções e políticas necessárias na conta em que o Amazon EMR está implantado, também chamada de *conta confiável*:
1. **Etapa 1**: recupere o ARN do [perfil de serviço do seu cluster do Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-iam-role.html).
Para saber como encontrar o ARN do perfil de serviço de um cluster, consulte [Configurar perfis de serviço do IAM para permissões do Amazon EMR aos serviços e recursos da AWS](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-iam-roles.html#emr-iam-role-landing).
1. **Etapa 2**: crie um perfil personalizado do IAM chamado `AssumableRole` com a seguinte configuração:
+ Permissões: conceda as permissões necessárias ao `AssumableRole` para permitir o acesso aos recursos do Amazon EMR. Essa função também é conhecida como *função de acesso* em cenários que envolvem acesso entre contas.
+ Relação de confiança: configure a política de confiança para `AssumableRole` a fim de permitir a atribuição do perfil de execução (o `SageMakerExecutionRole` no diagrama de contas cruzadas) pela conta do Studio que requer acesso.
Ao assumir a função, o Studio ou o Studio Classic podem obter acesso temporário às permissões necessárias no Amazon EMR.
Para obter instruções detalhadas sobre como criar uma nova `AssumableRole` em sua AWS conta do Amazon EMR, siga estas etapas:
1. Navegue até o [console do IAM](https://console.aws.amazon.com/iam).
1. No painel de navegação à esquerda, selecione **Política** e, em seguida, **Criar política**.
1. Na guia **JSON**, adicione as permissões do Amazon EMR que permitem o acesso e as operações do Amazon EMR. Para obter detalhes sobre o documento de política, consulte *Listar políticas do Amazon EMR* em [Políticas de referência](studio-set-up-emr-permissions-reference.md). Substitua a `region` e o `accountID` por seus valores reais antes de copiar a lista de instruções para a política em linha de seu perfil.
1. Escolha **Próximo** e, em seguida, forneça um **nome de política**.
1. Selecione **Criar política**.
1. No painel de navegação à esquerda, selecione **Funções** e, em seguida, **Criar função**.
1. Na página **Criar função**, escolha a opção **Política de confiança personalizada** como entidade confiável.
1. Cole o seguinte documento JSON na seção **Política de confiança personalizada** e escolha **Avançar**:
------
#### [ For users of Studio and JupyterLab ]
`studio-account`Substitua pelo ID da conta do Studio e `AmazonSageMaker-ExecutionRole` pela função de execução usada pelo seu JupyterLab espaço.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
------
#### [ For users of Studio Classic ]
Substitua `studio-account` pelo ID da conta do Studio Classic.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
------
1. Na página **Adicionar permissões**, adicione a permissão que você acabou de criar e escolha **Avançar**.
1. Na página **Revisar**, insira um nome para a função, como `AssumableRole`, e uma descrição opcional.
1. Revisar os detalhes do perfil e selecionar **Criar perfil**.
Para obter mais informações sobre como criar um perfil em uma conta da AWS , consulte [Criar um perfil do IAM (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html).
#### Na conta do Studio
Na conta em que o Studio está implantado, também chamada de *conta confiável*, atualize a função de execução da SageMaker IA acessando seus clusters com as permissões necessárias para acessar recursos na conta confiável.
1. **Etapa 1**: Recupere o ARN da função de execução SageMaker de IA usada pelo seu espaço privado.
Para obter informações sobre espaços e funções de execução na SageMaker IA, consulte[Compreendendo as permissões de espaço e os perfis de execução do domínio](execution-roles-and-spaces.md).
Para obter mais informações sobre como recuperar o ARN da função de execução SageMaker da IA, consulte. [Obtenha um perfil de execução](sagemaker-roles.md#sagemaker-roles-get-execution-role)
1. **Etapa 2**: anexe as seguintes permissões à função de execução de SageMaker IA acessando seus clusters do Amazon EMR.
1. Navegue até o [console do IAM](https://console.aws.amazon.com/iam).
1. Escolha **Perfis** e, em seguida, pesquise seu perfil de execução pelo nome no campo **Pesquisar**. O nome do perfil é a última parte do ARN, após a última barra (/).
1. Acesse o link do seu perfil.
1. Selecione **Adicionar permissões** e, em seguida, **Criar política em linha**.
1. Na guia **JSON**, adicione a política em linha que concede permissões à função para atualizar os domínios, perfis de usuário e espaços. Para obter detalhes sobre o documento de política, consulte *Política de ações de atualização de domínio, perfil de usuário e espaço* em [Políticas de referência](studio-set-up-emr-permissions-reference.md). Substitua a `region` e o `accountID` por seus valores reais antes de copiar a lista de instruções para a política em linha de seu perfil.
1. Escolha **Próximo** e, em seguida, forneça um **nome de política**.
1. Selecione **Criar política**.
1. Repita a etapa **Criar política em linha** para adicionar outra política que conceda ao perfil de execução as permissões para assumir `AssumableRole` e, em seguida, executar as ações permitidas pela política de acesso do perfil. Substitua `emr-account` pelo ID da conta do Amazon EMR e `AssumableRole` pelo nome do perfil a ser assumido que foi criado na conta do Amazon EMR.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowRoleAssumptionForCrossAccountDiscovery",
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": [
"arn:aws:iam::111122223333:role/AssumableRole"
]
}
]
}
```
------
1. Repita a etapa **Criar política em linha** para adicionar outra política que concede ao perfil de execução as permissões para provisionar novos clusters do Amazon EMR usando modelos do CloudFormation . Para obter detalhes sobre o documento de política, consulte *Criar EMRclusters políticas da Amazon* em[Políticas de referência](studio-set-up-emr-permissions-reference.md). Substitua a `region` e o `accountID` por seus valores reais antes de copiar a lista de instruções para a política em linha de seu perfil.
1. (Opcional) Para permitir a listagem de clusters do Amazon EMR implantados na mesma conta do Studio, adicione uma política em linha adicional ao seu perfil de execução do Studio, conforme definido em *Listar políticas do Amazon EMR* em [Políticas de referência](studio-set-up-emr-permissions-reference.md).
1. **Etapa 3**: associe suas funções presumíveis (função de acesso) ao seu domínio ou perfil de usuário. JupyterLab os usuários no Studio podem usar o console de SageMaker IA ou o script fornecido.
Escolha a guia que corresponde ao seu caso de uso.
------
#### [ Associate your assumable roles in JupyterLab using the SageMaker AI console ]
Para associar suas funções assumidas ao seu perfil de usuário ou domínio usando o console de SageMaker IA:
1. Navegue até o console de SageMaker IA em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. No painel de navegação esquerdo, escolha **domínio** e selecione o domínio usando a função de execução de SageMaker IA cujas permissões você atualizou.
1.
+ Para adicionar suas funções presumíveis (função de acesso) ao seu domínio: na guia **Configurações do aplicativo** da página de **detalhes do domínio**, navegue até a seção. **JupyterLab**
+ Para adicionar suas funções presumíveis (função de acesso) ao seu perfil de usuário: na página **Detalhes do domínio**, escolha a guia **Perfis de usuário** e selecione o perfil de usuário usando a função de execução de SageMaker IA cujas permissões você atualizou. Na guia **Configurações do aplicativo**, navegue até a **JupyterLab**seção.
1. Escolha **Editar** e adicione sua função presumível (função de acesso). ARNs
1. Selecione **Enviar**.
------
#### [ Associate your assumable roles in JupyterLab using a Python script ]
Em um JupyterLab aplicativo iniciado em um espaço usando a função de execução de SageMaker IA cujas permissões você atualizou, execute o comando a seguir em um terminal. Substitua `domainID`, `user-profile-name`, `emr-accountID` e `AssumableRole` (`EMRServiceRole` para [funções de runtime do RBAC]()) por seus valores adequados. Esse trecho de código atualiza as configurações do perfil do usuário para um perfil de usuário específico (uso`client.update_userprofile`) ou configurações de domínio (uso`client.update_domain`) em um domínio de SageMaker IA. Especificamente, ele permite que o JupyterLab aplicativo assuma uma função específica do IAM (`AssumableRole`) para executar clusters do Amazon EMR na conta do Amazon EMR.
```
import botocore.session
import json
sess = botocore.session.get_session()
client = sess.create_client('sagemaker')
client.update_userprofile(
DomainId="domainID",
UserProfileName="user-profile-name",
DefaultUserSettings={
'JupyterLabAppSettings': {
'EmrSettings': {
'AssumableRoleArns': ["arn:aws:iam::emr-accountID:role/AssumableRole"],
'ExecutionRoleArns': ["arn:aws:iam::emr-accountID:role/EMRServiceRole",
"arn:aws:iam::emr-accountID:role/AnotherServiceRole"]
}
}
})
resp = client.describe_user_profile(DomainId="domainID", UserProfileName=user-profile-name")
resp['CreationTime'] = str(resp['CreationTime'])
resp['LastModifiedTime'] = str(resp['LastModifiedTime'])
print(json.dumps(resp, indent=2))
```
------
#### [ For users of Studio Classic ]
Forneça o ARN do `AssumableRole` para seu perfil de execução do Studio Classic. O ARN é carregado pelo servidor do Jupyter na inicialização. O perfil de execução do Studio aceita essa função entre contas para descobrir e se conectar aos clusters do Amazon EMR na *conta confiável*.
É possível especificar essas informações usando scripts de configuração do ciclo de vida (LCC). Você pode anexar a LCC ao seu domínio ou a um perfil de usuário específico. O script de LCC que você usa deve ser uma JupyterServer configuração. Para obter mais informações sobre como criar um script de LCC, consulte [Usar configurações de ciclo de vida com o Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-lcc.html).
A seguir há um exemplo de script de LCC. Para modificar o script, substitua `AssumableRole` e `emr-account` por seus respectivos valores. O número de contas cruzadas é limitado a cinco.
```
# This script creates the file that informs Studio Classic that the role "arn:aws:iam::emr-account:role/AssumableRole" in remote account "emr-account" must be assumed to list and describe Amazon EMR clusters in the remote account.
#!/bin/bash
set -eux
FILE_DIRECTORY="/home/sagemaker-user/.cross-account-configuration-DO_NOT_DELETE"
FILE_NAME="emr-discovery-iam-role-arns-DO_NOT_DELETE.json"
FILE="$FILE_DIRECTORY/$FILE_NAME"
mkdir -p $FILE_DIRECTORY
cat > "$FILE" <<- "EOF"
{
emr-cross-account1: "arn:aws:iam::emr-cross-account1:role/AssumableRole",
emr-cross-account2: "arn:aws:iam::emr-cross-account2:role/AssumableRole"
}
EOF
```
Depois que a LCC é executada e os arquivos são gravados, o servidor lê o arquivo `/home/sagemaker-user/.cross-account-configuration-DO_NOT_DELETE/emr-discovery-iam-role-arns-DO_NOT_DELETE.json` e armazena o ARN entre contas.
------
# Configurar a listagem de clusters do Amazon EMR
Os administradores podem configurar permissões para a função de execução do SageMaker Studio para conceder aos usuários a capacidade de visualizar a lista de clusters do Amazon EMR aos quais eles têm acesso, permitindo que eles se conectem a esses clusters. Os clusters aos quais você deseja acessar podem ser implantados na mesma AWS conta do Studio (escolha *Conta única*) ou em contas separadas (escolha *Conta cruzada*). A página a seguir descreve como conceder as permissões para visualizar clusters do Amazon EMR a partir do Studio ou do Studio Classic.
**Importante**
Você só pode descobrir e se conectar aos clusters do Amazon EMR JupyterLab e aos aplicativos do Studio Classic que são lançados a partir de espaços privados. Certifique-se de que os clusters do Amazon EMR estejam localizados na mesma AWS região do seu ambiente Studio.
Para permitir que cientistas de dados descubram e se conectem à Amazon a EMRclusters partir do Studio ou do Studio Classic, siga estas etapas.
## Conta única
Se seus clusters do Amazon EMR e o Studio ou o Studio Classic estiverem implantados na mesma AWS conta, anexe as seguintes permissões à função de execução da SageMaker IA que acessa seu cluster.
1. **Etapa 1**: Recupere o ARN da função de execução SageMaker de IA usada pelo seu espaço privado.
Para obter informações sobre espaços e funções de execução na SageMaker IA, consulte[Compreendendo as permissões de espaço e os perfis de execução do domínio](execution-roles-and-spaces.md).
Para obter mais informações sobre como recuperar o ARN da função de execução SageMaker da IA, consulte. [Obtenha um perfil de execução](sagemaker-roles.md#sagemaker-roles-get-execution-role)
1. **Etapa 2**: anexe as seguintes permissões à função de execução de SageMaker IA acessando seus clusters do Amazon EMR.
1. Navegue até o [console do IAM](https://console.aws.amazon.com/iam).
1. Escolha **Perfis** e, em seguida, pesquise seu perfil de execução pelo nome no campo **Pesquisar**. O nome do perfil é a última parte do ARN, após a última barra (/).
1. Acesse o link do seu perfil.
1. Selecione **Adicionar permissões** e, em seguida, **Criar política em linha**.
1. Na guia **JSON**, adicione as permissões do Amazon EMR que permitem o acesso e as operações do Amazon EMR. Para obter detalhes sobre o documento de política, consulte *Listar políticas do Amazon EMR* em [Políticas de referência](studio-set-up-emr-permissions-reference.md). Substitua a `region` e o `accountID` por seus valores reais antes de copiar a lista de instruções para a política em linha de seu perfil.
1. Escolha **Próximo** e, em seguida, forneça um **nome de política**.
1. Selecione **Criar política**.
**nota**
Os usuários da conectividade de controle de acesso baseado em funções (RBAC) com os clusters do Amazon EMR também devem consultar [Configure a autenticação da função de runtime quando o cluster do Amazon EMR e o Studio estiverem na mesma conta](studio-notebooks-emr-cluster-rbac.md#studio-notebooks-emr-cluster-iam-same).
## Entre contas
Antes de começar, recupere o ARN da função de execução SageMaker de IA usada pelo seu espaço privado.
Para obter informações sobre espaços e funções de execução na SageMaker IA, consulte[Compreendendo as permissões de espaço e os perfis de execução do domínio](execution-roles-and-spaces.md).
Para obter mais informações sobre como recuperar o ARN da função de execução SageMaker da IA, consulte. [Obtenha um perfil de execução](sagemaker-roles.md#sagemaker-roles-get-execution-role)
Se seus clusters do Amazon EMR e o Studio ou o Studio Classic estiverem implantados em contas AWS separadas, você configura as permissões em ambas as contas.
**nota**
Os usuários da conectividade de controle de acesso baseado em funções (RBAC) com os clusters do Amazon EMR também devem consultar [Configure a autenticação da função de runtime quando o cluster do Studio estiver em contas diferentes](studio-notebooks-emr-cluster-rbac.md#studio-notebooks-emr-cluster-iam-diff).
**Na conta de cluster do Amazon EMR**
Siga estas etapas para criar as funções e políticas necessárias na conta em que o Amazon EMR está implantado, também chamada de *conta confiável*:
1. **Etapa 1**: recupere o ARN do [perfil de serviço do seu cluster do Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-iam-role.html).
Para saber como encontrar o ARN do perfil de serviço de um cluster, consulte [Configurar perfis de serviço do IAM para permissões do Amazon EMR aos serviços e recursos da AWS](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-iam-roles.html#emr-iam-role-landing).
1. **Etapa 2**: crie um perfil personalizado do IAM chamado `AssumableRole` com a seguinte configuração:
+ Permissões: conceda as permissões necessárias ao `AssumableRole` para permitir o acesso aos recursos do Amazon EMR. Essa função também é conhecida como *função de acesso* em cenários que envolvem acesso entre contas.
+ Relação de confiança: configure a política de confiança para `AssumableRole` a fim de permitir a atribuição do perfil de execução (o `SageMakerExecutionRole` no diagrama de contas cruzadas) pela conta do Studio que requer acesso.
Ao assumir a função, o Studio ou o Studio Classic podem obter acesso temporário às permissões necessárias no Amazon EMR.
Para obter instruções detalhadas sobre como criar uma nova `AssumableRole` em sua AWS conta do Amazon EMR, siga estas etapas:
1. Navegue até o [console do IAM](https://console.aws.amazon.com/iam).
1. No painel de navegação à esquerda, selecione **Política** e, em seguida, **Criar política**.
1. Na guia **JSON**, adicione as permissões do Amazon EMR que permitem o acesso e as operações do Amazon EMR. Para obter detalhes sobre o documento de política, consulte *Listar políticas do Amazon EMR* em [Políticas de referência](studio-set-up-emr-permissions-reference.md). Substitua a `region` e o `accountID` por seus valores reais antes de copiar a lista de instruções para a política em linha de seu perfil.
1. Escolha **Próximo** e, em seguida, forneça um **nome de política**.
1. Selecione **Criar política**.
1. No painel de navegação à esquerda, selecione **Funções** e, em seguida, **Criar função**.
1. Na página **Criar função**, escolha a opção **Política de confiança personalizada** como entidade confiável.
1. Cole o seguinte documento JSON na seção **Política de confiança personalizada** e escolha **Avançar**:
------
#### [ For users of Studio and JupyterLab ]
`studio-account`Substitua pelo ID da conta do Studio e `AmazonSageMaker-ExecutionRole` pela função de execução usada pelo seu JupyterLab espaço.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
------
#### [ For users of Studio Classic ]
Substitua `studio-account` pelo ID da conta do Studio Classic.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:root"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
------
1. Na página **Adicionar permissões**, adicione a permissão que você acabou de criar e escolha **Avançar**.
1. Na página **Revisar**, insira um nome para a função, como `AssumableRole`, e uma descrição opcional.
1. Revisar os detalhes do perfil e selecionar **Criar perfil**.
Para obter mais informações sobre como criar uma função em uma AWS conta, consulte [Criação de uma função do IAM (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html).
**Na conta do Studio**
Na conta em que o Studio está implantado, também chamada de *conta confiável*, atualize a função de execução da SageMaker IA acessando seus clusters com as permissões necessárias para acessar recursos na conta confiável.
1. **Etapa 1**: Recupere o ARN da função de execução SageMaker de IA usada pelo seu espaço privado.
Para obter informações sobre espaços e funções de execução na SageMaker IA, consulte[Compreendendo as permissões de espaço e os perfis de execução do domínio](execution-roles-and-spaces.md).
Para obter mais informações sobre como recuperar o ARN da função de execução SageMaker da IA, consulte. [Obtenha um perfil de execução](sagemaker-roles.md#sagemaker-roles-get-execution-role)
1. **Etapa 2**: anexe as seguintes permissões à função de execução de SageMaker IA acessando seus clusters do Amazon EMR.
1. Navegue até o [console do IAM](https://console.aws.amazon.com/iam).
1. Escolha **Perfis** e, em seguida, pesquise seu perfil de execução pelo nome no campo **Pesquisar**. O nome do perfil é a última parte do ARN, após a última barra (/).
1. Acesse o link do seu perfil.
1. Selecione **Adicionar permissões** e, em seguida, **Criar política em linha**.
1. Na guia **JSON**, adicione a política em linha que concede permissões à função para atualizar os domínios, perfis de usuário e espaços. Para obter detalhes sobre o documento de política, consulte *Política de ações de atualização de domínio, perfil de usuário e espaço* em [Políticas de referência](studio-set-up-emr-permissions-reference.md). Substitua a `region` e o `accountID` por seus valores reais antes de copiar a lista de instruções para a política em linha de seu perfil.
1. Escolha **Próximo** e, em seguida, forneça um **nome de política**.
1. Selecione **Criar política**.
1. Repita a etapa **Criar política em linha** para adicionar outra política que conceda ao perfil de execução as permissões para assumir `AssumableRole` e, em seguida, executar as ações permitidas pela política de acesso do perfil. Substitua `emr-account` pelo ID da conta do Amazon EMR e `AssumableRole` pelo nome do perfil a ser assumido que foi criado na conta do Amazon EMR.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowRoleAssumptionForCrossAccountDiscovery",
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": [
"arn:aws:iam::111122223333:role/AssumableRole"
]
}
]
}
```
------
1. (Opcional) Para permitir a listagem de clusters do Amazon EMR implantados na mesma conta do Studio, adicione uma política em linha adicional ao seu perfil de execução do Studio, conforme definido em *Listar políticas do Amazon EMR* em [Políticas de referência](studio-set-up-emr-permissions-reference.md).
1. **Etapa 3**: associe suas funções presumíveis (função de acesso) ao seu domínio ou perfil de usuário. JupyterLabos usuários no Studio podem usar o console de SageMaker IA ou o script fornecido.
Escolha a guia que corresponde ao seu caso de uso.
------
#### [ Associate your assumable roles in JupyterLab using the SageMaker AI console ]
Para associar suas funções assumidas ao seu perfil de usuário ou domínio usando o console de SageMaker IA:
1. Navegue até o console de SageMaker IA em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. No painel de navegação esquerdo, escolha **domínio** e selecione o domínio usando a função de execução de SageMaker IA cujas permissões você atualizou.
1.
+ Para adicionar suas funções presumíveis (função de acesso) ao seu domínio: na guia **Configurações do aplicativo** da página de **detalhes do domínio**, navegue até a seção. **JupyterLab**
+ Para adicionar suas funções presumíveis (função de acesso) ao seu perfil de usuário: na página **Detalhes do domínio**, escolha a guia **Perfis de usuário** e selecione o perfil de usuário usando a função de execução de SageMaker IA cujas permissões você atualizou. Na guia **Configurações do aplicativo**, navegue até a **JupyterLab**seção.
1. Escolha **Editar** e adicione sua função presumível (função de acesso). ARNs
1. Selecione **Enviar**.
------
#### [ Associate your assumable roles in JupyterLab using a Python script ]
Em um JupyterLab aplicativo iniciado em um espaço usando a função de execução de SageMaker IA cujas permissões você atualizou, execute o comando a seguir em um terminal. Substitua `domainID`, `user-profile-name`, `emr-accountID` e `AssumableRole` (`EMRServiceRole` para [funções de runtime do RBAC]()) por seus valores adequados. Esse trecho de código atualiza as configurações do perfil do usuário para um perfil de usuário específico (uso`client.update_userprofile`) ou configurações de domínio (uso`client.update_domain`) em um domínio de SageMaker IA. Especificamente, ele permite que o JupyterLab aplicativo assuma uma função específica do IAM (`AssumableRole`) para executar clusters do Amazon EMR na conta do Amazon EMR.
```
import botocore.session
import json
sess = botocore.session.get_session()
client = sess.create_client('sagemaker')
client.update_userprofile(
DomainId="domainID",
UserProfileName="user-profile-name",
DefaultUserSettings={
'JupyterLabAppSettings': {
'EmrSettings': {
'AssumableRoleArns': ["arn:aws:iam::emr-accountID:role/AssumableRole"],
'ExecutionRoleArns': ["arn:aws:iam::emr-accountID:role/EMRServiceRole",
"arn:aws:iam::emr-accountID:role/AnotherServiceRole"]
}
}
})
resp = client.describe_user_profile(DomainId="domainID", UserProfileName=user-profile-name")
resp['CreationTime'] = str(resp['CreationTime'])
resp['LastModifiedTime'] = str(resp['LastModifiedTime'])
print(json.dumps(resp, indent=2))
```
------
#### [ For users of Studio Classic ]
Forneça o ARN do `AssumableRole` para seu perfil de execução do Studio Classic. O ARN é carregado pelo servidor do Jupyter na inicialização. O perfil de execução do Studio aceita essa função entre contas para descobrir e se conectar aos clusters do Amazon EMR na *conta confiável*.
É possível especificar essas informações usando scripts de configuração do ciclo de vida (LCC). Você pode anexar a LCC ao seu domínio ou a um perfil de usuário específico. O script de LCC que você usa deve ser uma JupyterServer configuração. Para obter mais informações sobre como criar um script de LCC, consulte [Usar configurações de ciclo de vida com o Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-lcc.html).
A seguir há um exemplo de script de LCC. Para modificar o script, substitua `AssumableRole` e `emr-account` por seus respectivos valores. O número de contas cruzadas é limitado a cinco.
```
# This script creates the file that informs Studio Classic that the role "arn:aws:iam::emr-account:role/AssumableRole" in remote account "emr-account" must be assumed to list and describe Amazon EMR clusters in the remote account.
#!/bin/bash
set -eux
FILE_DIRECTORY="/home/sagemaker-user/.cross-account-configuration-DO_NOT_DELETE"
FILE_NAME="emr-discovery-iam-role-arns-DO_NOT_DELETE.json"
FILE="$FILE_DIRECTORY/$FILE_NAME"
mkdir -p $FILE_DIRECTORY
cat > "$FILE" <<- "EOF"
{
emr-cross-account1: "arn:aws:iam::emr-cross-account1:role/AssumableRole",
emr-cross-account2: "arn:aws:iam::emr-cross-account2:role/AssumableRole"
}
EOF
```
Depois que a LCC é executada e os arquivos são gravados, o servidor lê o arquivo `/home/sagemaker-user/.cross-account-configuration-DO_NOT_DELETE/emr-discovery-iam-role-arns-DO_NOT_DELETE.json` e armazena o ARN entre contas.
------
Consulte [Listar clusters do Amazon EMR no Studio ou no Studio Classic](discover-emr-clusters.md) para saber como descobrir e se conectar aos clusters do Amazon EMR a partir dos cadernos do Studio ou Studio Classic.
# Configurar perfis de runtime do IAM para acesso ao cluster do Amazon EMR no Studio
Ao se conectar a um cluster do Amazon EMR a partir do seu caderno do Studio ou Studio Classic, você pode visualizar uma lista de perfis do IAM, conhecidos como funções de runtime, e selecionar uma delas rapidamente. Posteriormente, todos os seus trabalhos do Apache Spark, Apache Hive ou Presto criados no seu caderno do Studio acessarão somente os dados e recursos permitidos pelas políticas anexadas à função de runtime. Além disso, quando os dados são acessados a partir de data lakes gerenciados com AWS Lake Formation, você pode impor o acesso em nível de tabela e coluna usando políticas anexadas à função de tempo de execução.
Com esse recurso, você e seus colegas de equipe podem se conectar ao mesmo cluster, cada um usando uma função de runtime com permissões correspondentes ao seu nível individual de acesso aos dados. Suas sessões também são isoladas umas das outras no cluster compartilhado.
Para experimentar esse recurso usando o Studio Classic, consulte [Aplicar controles refinados de acesso a dados com e o AWS Lake Formation Amazon EMR do Amazon](https://aws.amazon.com/blogs/machine-learning/apply-fine-grained-data-access-controls-with-aws-lake-formation-and-amazon-emr-from-amazon-sagemaker-studio/) Studio Classic. SageMaker Esta postagem do blog ajuda você a configurar um ambiente de demonstração no qual você pode tentar usar funções de runtime pré-configuradas para se conectar aos clusters do Amazon EMR.
## Pré-requisitos
Antes começar, certifique-se de que os seguintes pré-requisitos sejam atendidos:
+ Use o Amazon EMR versão 6.9 ou superior.
+ **Para usuários do Studio Classic**: Use a JupyterLab versão 3 na configuração do aplicativo do servidor Studio Classic Jupyter. Essa versão oferece apoio à conexão do Studio Classic com clusters do Amazon EMR usando funções de runtime.
**Para usuários do Studio**: use uma versão [SageMaker de imagem de distribuição](sagemaker-distribution.md) `1.10` ou superior.
+ Permita o uso de perfis de runtime na configuração de segurança do cluster. Para obter mais informações, consulte [Funções de runtime para as etapas do Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-steps-runtime-roles.html).
+ Crie um caderno com qualquer um dos kernels listados em [Imagens e kernels compatíveis para se conectar a um cluster do Amazon EMR no Studio ou Studio Classic](studio-emr-user-guide.md#studio-notebooks-emr-cluster-connect-kernels).
+ Não se esqueça de revisar as instruções em [Configurar o Studio para usar funções do IAM em runtime](#studio-notebooks-emr-cluster-iam) para configurar as funções de runtime.
## Cenários de conexão entre contas
A autenticação por função de runtime oferece apoio a vários cenários de conexão entre contas quando seus dados residem fora da sua conta do Studio. A imagem a seguir mostra três maneiras diferentes de atribuir seu cluster, dados e até mesmo a função de runtime do Amazon EMR entre seu Studio e suas contas de dados:
![\[Cenários entre contas compatíveis com autenticação de perfil do IAM em runtime.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio-emr-rbac-scenarios.png)
Na opção 1, seu cluster do Amazon EMR e a função de runtime do Amazon EMR estão em uma conta de dados separada da sua conta do Studio. Você define uma política de permissão de função de acesso do Amazon EMR (também referida como `Assumable role`) separada que concede permissão ao seu perfil de execução do Studio ou Studio Classic para assumir a função de acesso do Amazon EMR. A função de acesso do Amazon EMR, então, chama a API `GetClusterSessionCredentials` do Amazon EMR em nome do seu perfil de execução do Studio ou Studio Classic, dando acesso ao cluster.
Na opção 2, seu cluster do Amazon EMR e a função de runtime do Amazon EMR estão na sua conta do Studio. Sua função de execução do Studio tem permissão para usar a API do Amazon EMR `GetClusterSessionCredentials` para obter acesso ao seu cluster. Para acessar o bucket do Amazon S3, conceda à função de runtime do Amazon EMR permissões de acesso ao bucket do Amazon S3 entre contas: você concede essas permissões dentro da sua política de bucket do Amazon S3.
Na opção 3, seus clusters do Amazon EMR estão na sua conta do Studio, e o perfil de runtime do Amazon EMR está na sua conta de dados. Seu perfil de execução do Studio ou Studio Classic tem permissão para usar a API `GetClusterSessionCredentials` do Amazon EMR para obter acesso ao seu cluster. Adicione a função de runtime do Amazon EMR ao JSON de configuração da função de execução. Em seguida, você pode selecionar a função na interface do usuário ao escolher seu cluster. Para obter detalhes sobre como configurar seu arquivo JSON de configuração da função de execução, consulte [Pré-carregar seus perfis de execução no Studio ou Studio Classic](#studio-notebooks-emr-cluster-iam-preload).
## Configurar o Studio para usar funções do IAM em runtime
Para estabelecer a autenticação de função de runtime para seus clusters do Amazon EMR, configure as políticas do IAM, a rede e os aprimoramentos de usabilidade necessários. Sua configuração depende de você lidar com regras entre contas, se seus clusters do Amazon EMR, função de runtime do Amazon EMR ou ambos residirem fora da sua conta do Studio. A discussão a seguir orienta você sobre as políticas de instalação, como configurar a rede para permitir o tráfego entre contas e o arquivo de configuração local a ser configurado para automatizar sua conexão com o Amazon EMR.
### Configure a autenticação da função de runtime quando o cluster do Amazon EMR e o Studio estiverem na mesma conta
Se seu cluster do Amazon EMR residir em sua conta do Studio, conclua as seguintes etapas para adicionar as permissões necessárias à sua política de execução do Studio:
1. Adicione a política do IAM necessária para se conectar aos clusters do Amazon EMR. Para obter detalhes, consulte [Configurar a listagem de clusters do Amazon EMR](studio-notebooks-configure-discoverability-emr-cluster.md).
1. Conceda permissão para chamar a API `GetClusterSessionCredentials` do Amazon EMR ao passar uma ou mais funções de runtime do Amazon EMR permitidas e especificadas na política.
1. (Opcional) Conceda permissão para transmitir funções do IAM que sigam qualquer convenção de nomenclatura definida pelo usuário.
1. (Opcional) Conceda permissão para acessar clusters do Amazon EMR que são marcados com cadeias de caracteres específicas definidas pelo usuário.
1. Pré-carregue seus perfis do IAM para que você possa selecionar a função a ser usada ao se conectar ao seu cluster do Amazon EMR. Para saber detalhes sobre como pré-carregar suas funções do IAM, consulte [Pré-carregar seus perfis de execução no Studio ou Studio Classic](#studio-notebooks-emr-cluster-iam-preload).
O exemplo de política a seguir permite que funções de runtime do Amazon EMR pertencentes aos grupos de modelagem e treinamento chamem `GetClusterSessionCredentials`. Além disso, o segurado pode acessar clusters do Amazon EMR marcados com as sequências de caracteres `modeling` ou `training`.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": "elasticmapreduce:GetClusterSessionCredentials",
"Resource": "*",
"Condition": {
"ArnLike": {
"elasticmapreduce:ExecutionRoleArn": [
"arn:aws:iam::111122223333:role/emr-execution-role-ml-modeling*",
"arn:aws:iam::111122223333:role/emr-execution-role-ml-training*"
]},
"StringLike":{
"elasticmapreduce:ResourceTag/group": [
"*modeling*",
"*training*"
]
}
}
}
]
}
```
------
### Configure a autenticação da função de runtime quando o cluster do Studio estiver em contas diferentes
Se seu cluster do Amazon EMR não estiver em sua conta do Studio, permita que sua função de execução de SageMaker IA assuma a função de acesso entre contas do Amazon EMR para que você possa se conectar ao cluster. Conclua as seguintes etapas para configurar sua configuração entre contas:
1. Crie sua política de permissão de função de execução de SageMaker IA para que a função de execução possa assumir a função de acesso ao Amazon EMR. Veja abaixo um exemplo de política:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowAssumeCrossAccountEMRAccessRole",
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::111122223333:role/emr-access-role-name"
}
]
}
```
------
1. Crie a política de confiança para especificar quais contas do Studio IDs são confiáveis para assumir a função de acesso ao Amazon EMR. Veja abaixo um exemplo de política:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowCrossAccountSageMakerExecutionRoleToAssumeThisRole",
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:role/studio_execution_role"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Crie a política de permissão da função de acesso do Amazon EMR, que concede à função de runtime do Amazon EMR as permissões necessárias para realizar as tarefas pretendidas no cluster. Configure a função de acesso do Amazon EMR para chamar a API `GetClusterSessionCredentials` com as funções de runtime do Amazon EMR especificadas na política de permissão da função de acesso. Veja abaixo um exemplo de política:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowCallingEmrGetClusterSessionCredentialsAPI",
"Effect": "Allow",
"Action": "elasticmapreduce:GetClusterSessionCredentials",
"Resource": "arn:aws:elasticmapreduce:us-east-1:111122223333:cluster/cluster-id",
"Condition": {
"StringLike": {
"elasticmapreduce:ExecutionRoleArn": [
"arn:aws:iam::111122223333:role/emr-execution-role-name"
]
}
}
}
]
}
```
------
1. Configure a rede entre contas para que o tráfego possa ir e voltar entre suas contas. Para obter instruções, consulte *Configurar o [Configurar o acesso à rede para o cluster do Amazon EMR](studio-notebooks-emr-networking.md)*. As etapas nessa seção ajudam você a concluir as seguintes tarefas:
1. VPC-Peer sua conta do Studio e sua conta do Amazon EMR para estabelecer uma conexão.
1. Adicione rotas manualmente às tabelas de rotas da sub-rede privada em ambas as contas. Isso permite a criação e a conexão de clusters do Amazon EMR da conta do Studio à sub-rede privada da conta remota.
1. Configure o grupo de segurança anexado ao seu domínio do Studio para permitir o tráfego de saída e o grupo de segurança do nó primário do Amazon EMR para permitir o tráfego TCP de entrada do grupo de segurança da instância do Studio.
1. Pré-carregar suas funções de runtime do IAM para que você possa selecionar a função a ser usada ao se conectar ao seu cluster do Amazon EMR. Para saber detalhes sobre como pré-carregar suas funções do IAM, consulte [Pré-carregar seus perfis de execução no Studio ou Studio Classic](#studio-notebooks-emr-cluster-iam-preload).
### Configurar o acesso ao Lake Formation
Ao acessar dados de data lakes gerenciados pelo AWS Lake Formation, você pode impor o acesso em nível de tabela e coluna usando políticas anexadas à sua função de tempo de execução. Para configurar a permissão para acesso ao Lake Formation, consulte [Integrar o Amazon EMR com AWS Lake Formation](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-lake-formation.html).
### Pré-carregar seus perfis de execução no Studio ou Studio Classic
Você pode pré-carregar suas funções de runtime do IAM para poder selecionar a função a ser usada ao se conectar ao seu cluster do Amazon EMR. Os usuários do JupyterLab in Studio podem usar o console de SageMaker IA ou o script fornecido.
------
#### [ Preload runtime roles in JupyterLab using the SageMaker AI console ]
Para associar suas funções de tempo de execução ao seu perfil de usuário ou domínio usando o console de SageMaker IA:
1. Navegue até o console de SageMaker IA em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. No painel de navegação esquerdo, escolha **domínio** e selecione o domínio usando a função de execução de SageMaker IA cujas permissões você atualizou.
1.
+ Para adicionar seu tempo de execução (e funções de acesso para casos de uso entre contas) ao seu domínio: na guia **Configurações do aplicativo** da página de **detalhes do domínio**, navegue até a **JupyterLab**seção.
+ Para adicionar seu tempo de execução (e funções de acesso para casos de uso entre contas) ao seu perfil de usuário: na página de **detalhes do domínio**, escolha a guia **Perfis de usuário**, selecione o perfil de usuário usando a função de execução de SageMaker IA cujas permissões você atualizou. Na guia **Configurações do aplicativo**, navegue até a **JupyterLab**seção.
1. Escolha **Editar** e adicione a sua função ARNs de acesso (função presumível) e as funções de execução de tempo de execução do EMR Serverless.
1. Selecione **Enviar**.
Na próxima vez em que você se conectar a um servidor do Amazon EMR, as funções de runtime devem aparecer em um menu suspenso para seleção.
------
#### [ Preload runtime roles in JupyterLab using a Python script ]
Em um JupyterLab aplicativo iniciado em um espaço usando a função de execução de SageMaker IA cujas permissões você atualizou, execute o comando a seguir em um terminal. Substitua `domainID`, `user-profile-name`, `emr-accountID` e `EMRServiceRole` por seus valores apropriados. Esse trecho de código atualiza as configurações do perfil do usuário (`client.update_user_profile`) em um domínio de SageMaker IA em um caso de uso entre contas. Especificamente, ele define os perfis de serviço do Amazon EMR. Também permite que o JupyterLab aplicativo assuma uma função específica do IAM (`AssumableRole`ou`AccessRole`) para executar o Amazon EMR na conta do Amazon EMR.
Como alternativa, use `client.update_domain` para atualizar as configurações do domínio se seu espaço usar um perfil de execução definido no nível do domínio.
```
import botocore.session
import json
sess = botocore.session.get_session()
client = sess.create_client('sagemaker')
client.update_user_profile(
DomainId="domainID",
UserProfileName="user-profile-name",
UserSettings={
'JupyterLabAppSettings': {
'EmrSettings': {
'AssumableRoleArns': ["arn:aws:iam::emr-accountID:role/AssumableRole"],
'ExecutionRoleArns': ["arn:aws:iam::emr-accountID:role/EMRServiceRole",
"arn:aws:iam::emr-accountID:role/AnotherServiceRole"]
}
}
})
resp = client.describe_user_profile(DomainId="domainID", UserProfileName=user-profile-name")
resp['CreationTime'] = str(resp['CreationTime'])
resp['LastModifiedTime'] = str(resp['LastModifiedTime'])
print(json.dumps(resp, indent=2))
```
------
#### [ Preload runtime roles in Studio Classic ]
Forneça o ARN do `AccessRole` (`AssumableRole`) para sua função de execução de SageMaker IA. O ARN é carregado pelo servidor do Jupyter na inicialização. O perfil de execução do Studio aceita essa função entre contas para descobrir e se conectar aos clusters do Amazon EMR na *conta confiável*.
É possível especificar essas informações usando scripts de configuração do ciclo de vida (LCC). Você pode anexar a LCC ao seu domínio ou a um perfil de usuário específico. O script de LCC que você usa deve ser uma JupyterServer configuração. Para obter mais informações sobre como criar um script de LCC, consulte [Usar configurações de ciclo de vida com o Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-lcc.html).
A seguir há um exemplo de script de LCC. Para modificar o script, substitua `AssumableRole` e `emr-account` por seus respectivos valores. O número de contas cruzadas é limitado a cinco.
O trecho a seguir é um exemplo de script Bash de LCC que você pode aplicar se a aplicação do Studio Classic e o cluster estiverem na mesma conta:
```
#!/bin/bash
set -eux
FILE_DIRECTORY="/home/sagemaker-user/.sagemaker-analytics-configuration-DO_NOT_DELETE"
FILE_NAME="emr-configurations-DO_NOT_DELETE.json"
FILE="$FILE_DIRECTORY/$FILE_NAME"
mkdir -p $FILE_DIRECTORY
cat << 'EOF' > "$FILE"
{
"emr-execution-role-arns":
{
"123456789012": [
"arn:aws:iam::123456789012:role/emr-execution-role-1",
"arn:aws:iam::123456789012:role/emr-execution-role-2"
]
}
}
EOF
```
Se a aplicação e os clusters do Studio Classic estiverem em contas diferentes, especifique as funções de acesso do Amazon EMR que podem usar o cluster. No exemplo de política a seguir, *123456789012 é* o ID da conta de cluster do Amazon EMR, *e 212121212121 *e** 434343434343 são as funções de acesso permitidas do Amazon EMR. ARNs
```
#!/bin/bash
set -eux
FILE_DIRECTORY="/home/sagemaker-user/.sagemaker-analytics-configuration-DO_NOT_DELETE"
FILE_NAME="emr-configurations-DO_NOT_DELETE.json"
FILE="$FILE_DIRECTORY/$FILE_NAME"
mkdir -p $FILE_DIRECTORY
cat << 'EOF' > "$FILE"
{
"emr-execution-role-arns":
{
"123456789012": [
"arn:aws:iam::212121212121:role/emr-execution-role-1",
"arn:aws:iam::434343434343:role/emr-execution-role-2"
]
}
}
EOF
# add your cross-account EMR access role
FILE_DIRECTORY="/home/sagemaker-user/.cross-account-configuration-DO_NOT_DELETE"
FILE_NAME="emr-discovery-iam-role-arns-DO_NOT_DELETE.json"
FILE="$FILE_DIRECTORY/$FILE_NAME"
mkdir -p $FILE_DIRECTORY
cat << 'EOF' > "$FILE"
{
"123456789012": "arn:aws:iam::123456789012:role/cross-account-emr-access-role"
}
EOF
```
------
# Políticas de referência
+ **Listar as políticas do Amazon EMR**: essa política permite realizar as seguintes ações:
+ `AllowPresignedUrl`permite gerar pré-assinados URLs para acessar a interface do usuário do Spark de dentro do Studio.
+ `AllowClusterDiscovery` e `AllowClusterDetailsDiscovery` permite listar e descrever clusters do Amazon EMR na região e na conta fornecidas.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowPresignedUrl",
"Effect": "Allow",
"Action": [
"elasticmapreduce:CreatePersistentAppUI",
"elasticmapreduce:DescribePersistentAppUI",
"elasticmapreduce:GetPersistentAppUIPresignedURL",
"elasticmapreduce:GetOnClusterAppUIPresignedURL"
],
"Resource": [
"arn:aws:elasticmapreduce:us-east-1:111122223333:cluster/*"
]
},
{
"Sid": "AllowClusterDetailsDiscovery",
"Effect": "Allow",
"Action": [
"elasticmapreduce:DescribeCluster",
"elasticmapreduce:ListInstances",
"elasticmapreduce:ListInstanceGroups",
"elasticmapreduce:DescribeSecurityConfiguration"
],
"Resource": [
"arn:aws:elasticmapreduce:us-east-1:111122223333:cluster/*"
]
},
{
"Sid": "AllowClusterDiscovery",
"Effect": "Allow",
"Action": [
"elasticmapreduce:ListClusters"
],
"Resource": "*"
}
]
}
```
------
+ **Criar políticas de clusters do Amazon EMR**: essa política permite realizar as seguintes ações:
+ `AllowEMRTemplateDiscovery` permite pesquisar modelos do Amazon EMR no Service Catalog. O Studio e o Studio Classic usam isso para mostrar os modelos disponíveis.
+ `AllowSagemakerProjectManagement` permite a criação de [O que é um projeto de SageMaker IA?](sagemaker-projects-whatis.md). No Studio ou no Studio Classic, o acesso ao AWS Service Catalog é gerenciado por meio de[O que é um projeto de SageMaker IA?](sagemaker-projects-whatis.md).
A política do IAM definida no JSON fornecido concede essas permissões. Substitua *region* e *accountID* por seus valores reais de região e ID da AWS conta antes de copiar a lista de extratos para a política embutida de sua função.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowEMRTemplateDiscovery",
"Effect": "Allow",
"Action": [
"servicecatalog:SearchProducts"
],
"Resource": "*"
},
{
"Sid": "AllowSagemakerProjectManagement",
"Effect": "Allow",
"Action": [
"sagemaker:CreateProject",
"sagemaker:DeleteProject"
],
"Resource": "arn:aws:sagemaker:us-east-1:111122223333:project/*"
}
]
}
```
------
+ **Política de ações de atualização de domínio, perfil de usuário e espaço**: a política a seguir concede permissões para atualizar domínios, perfis de usuário e espaços de SageMaker IA na região e na AWS conta especificadas.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "SageMakerUpdateResourcesPolicy",
"Effect": "Allow",
"Action": [
"sagemaker:UpdateDomain",
"sagemaker:UpdateUserprofile",
"sagemaker:UpdateSpace"
],
"Resource": [
"arn:aws:sagemaker:us-east-1:111122223333:domain/*",
"arn:aws:sagemaker:us-east-1:111122223333:user-profile/*"
]
}
]
}
```
------
# Guia do usuário
Esta seção aborda como os cientistas e engenheiros de dados podem iniciar, descobrir, conectar-se ou encerrar um cluster do Amazon EMR no Studio ou Studio Classic.
Antes que os usuários possam listar ou iniciar clusters, os administradores devem ter definido as configurações necessárias no ambiente do Studio. Para obter informações sobre como os administradores podem configurar um ambiente do Studio para permitir o provisionamento automático e a listagem de clusters do Amazon EMR, consulte [Guia de administrador](studio-emr-admin-guide.md).
**Topics**
+ [Imagens e kernels compatíveis para se conectar a um cluster do Amazon EMR no Studio ou Studio Classic](#studio-notebooks-emr-cluster-connect-kernels)
+ [Traga sua própria imagem](#studio-notebooks-emr-byoi)
+ [Inicializar um cluster do Amazon EMR no Studio ou Studio Classic](studio-notebooks-launch-emr-cluster-from-template.md)
+ [Listar clusters do Amazon EMR no Studio ou no Studio Classic](discover-emr-clusters.md)
+ [Conecte-se a um cluster do Amazon EMR a partir do SageMaker Studio ou do Studio Classic](connect-emr-clusters.md)
+ [Encerrar um cluster do Amazon EMR no Studio ou Studio Classic](terminate-emr-clusters.md)
+ [Acesse a interface de usuário do Spark no Studio ou no Studio Classic](studio-notebooks-access-spark-ui.md)
## Imagens e kernels compatíveis para se conectar a um cluster do Amazon EMR no Studio ou Studio Classic
[As imagens e os kernels a seguir vêm com [sagemaker-studio-analytics-extension](https://pypi.org/project/sagemaker-studio-analytics-extension/)a JupyterLab extensão que se conecta a um cluster remoto do Spark (Amazon EMR) por meio da biblioteca usando o [SparkMagic](https://github.com/jupyter-incubator/sparkmagic)Apache Livy.](https://livy.apache.org/)
+ **Para usuários do Studio:** SageMaker Distribution é um ambiente Docker para ciência de dados usado como imagem padrão das instâncias do JupyterLab notebook. Todas as versões do [SageMaker AI Distribution](https://github.com/aws/sagemaker-distribution) vêm `sagemaker-studio-analytics-extension` pré-instaladas.
+ **Para usuários do Studio Classic:** as imagens a seguir vêm pré-instaladas com `sagemaker-studio-analytics-extension`:
+ DataScience — Kernel Python 3
+ DataScience 2.0 — Kernel do Python 3
+ DataScience 3.0 — Kernel do Python 3
+ SparkAnalytics 1.0 — SparkMagic e PySpark grãos
+ SparkAnalytics 2.0 — SparkMagic e PySpark grãos
+ SparkMagic — SparkMagic e PySpark grãos
+ PyTorch 1.8 — Núcleos do Python 3
+ TensorFlow 2.6 — Kernel do Python 3
+ TensorFlow 2.11 — Kernel do Python 3
Para se conectar aos clusters do Amazon EMR usando outra imagem integrada ou sua própria imagem, siga as instruções em [Traga sua própria imagem](#studio-notebooks-emr-byoi).
## Traga sua própria imagem
Para trazer sua própria imagem no Studio ou no Studio Classic e permitir que seus notebooks se conectem aos clusters do Amazon EMR, instale a [sagemaker-studio-analytics-extension](https://pypi.org/project/sagemaker-studio-analytics-extension/)seguinte extensão em seu kernel. Ele suporta a conexão de notebooks SageMaker Studio ou Studio Classic a clusters Spark (Amazon EMR) por meio da biblioteca. [SparkMagic](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-studio-magics.html)
```
pip install sparkmagic
pip install sagemaker-studio-sparkmagic-lib
pip install sagemaker-studio-analytics-extension
```
Além disso, para se conectar ao Amazon EMR com a autenticação [Kerberos](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-kerberos.html), você deve instalar o cliente kinit. Dependendo do seu sistema operacional, o comando para instalar o cliente kinit pode variar. Para trazer uma imagem do Ubuntu (baseada no Debian), use o comando `apt-get install -y -qq krb5-user`.
Para obter mais informações sobre como trazer sua própria imagem no SageMaker Studio ou no Studio Classic, consulte [Traga sua própria SageMaker imagem](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-byoi.html).
# Inicializar um cluster do Amazon EMR no Studio ou Studio Classic
Cientistas e engenheiros de dados podem autoprovisionar clusters do Amazon EMR a partir do Studio ou do Studio Classic CloudFormation usando modelos configurados por seus administradores. Antes que os usuários possam iniciar um cluster, os administradores devem ter definido as configurações necessárias no ambiente do Studio. Para obter informações sobre como os administradores podem configurar um ambiente do Studio para permitir o provisionamento automático de clusters do Amazon EMR, consulte [Configurar CloudFormation modelos do Amazon EMR no Service Catalog](studio-notebooks-set-up-emr-templates.md).
Para provisionar um novo cluster do Amazon EMR no Studio ou Studio Classic:
1. No painel esquerdo da interface de usuário do Studio ou do Studio Classic, selecione o nó **Dados** no menu de navegação esquerdo. Navegue até os **clusters do Amazon EMR.** Isso abre uma página listando os clusters do Amazon EMR que você pode acessar no Studio ou Studio Classic.
1. Escolha o botão **Criar** no canto superior direito. Isso abre um novo modal listando os modelos de cluster disponíveis para você.
1. Selecione um modelo de cluster escolhendo um nome de modelo e, em seguida, escolha **Avançar**.
1. Insira os detalhes do cluster, como o nome do cluster e qualquer parâmetro configurável específico definido pelo administrador; depois escolha **Criar cluster**. A criação do cluster pode levar alguns minutos.
![\[Formulário de criação de cluster do Amazon EMR no Studio ou Studio Classic.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/emr/studio-notebooks-emr-cluster-creation.png)
Depois que o cluster é provisionado, a interface do usuário do Studio ou Studio Classic exibe a mensagem *O cluster foi criado com êxito*.
Para se conectar e usar o cluster, consulte [Conecte-se a um cluster do Amazon EMR a partir do SageMaker Studio ou do Studio Classic](connect-emr-clusters.md)
# Listar clusters do Amazon EMR no Studio ou no Studio Classic
Os cientistas e engenheiros de dados podem descobrir e se conectar a clusters do Amazon EMR no Studio. Os clusters do Amazon EMR podem estar na mesma AWS conta do Studio ou em uma conta diferente AWS .
Antes que os usuários possam listar ou se conectar aos clusters, os administradores devem ter definido as configurações necessárias no ambiente do Studio. Para obter informações sobre como os administradores podem configurar um ambiente do Studio para permitir a descoberta de clusters do Amazon EMR em execução, consulte [Guia de administrador](studio-emr-admin-guide.md). Se seu administrador [configurou a descoberta entre contas de clusters do Amazon EMR](studio-notebooks-configure-discoverability-emr-cluster.md), você pode ver uma lista consolidada de clusters. A lista inclui clusters da AWS conta usada pelo Studio, bem como clusters de contas remotas às quais você recebeu acesso.
Para ver a lista de clusters do Amazon EMR disponíveis no Studio:
1. No menu de navegação à esquerda da interface do Studio, role para baixo até **Clusters do EMR**. Isso abre uma página listando os clusters do Amazon EMR aos quais você pode acessar.
A lista exibe clusters nos seguintes estágios: **Bootstrapping**, **Starting** **Running**, **Waiting**. Você pode restringir os clusters exibidos pelo status atual usando o ícone de filtro.
1. Escolha um cluster em **execução** específico ao qual você deseja se conectar e, em seguida, consulte [Conecte-se a um cluster do Amazon EMR a partir do SageMaker Studio ou do Studio Classic](connect-emr-clusters.md).
# Conecte-se a um cluster do Amazon EMR a partir do SageMaker Studio ou do Studio Classic
Os cientistas e engenheiros de dados podem descobrir e se conectar a um cluster do Amazon EMR diretamente da interface de usuário do Studio. Antes de começar, certifique-se de ter configurado as permissões necessárias, conforme descrito na seção [Etapa 4: configure as permissões para permitir a listagem e a inicialização de clusters do Amazon EMR a partir do Studio](studio-notebooks-set-up-emr-templates.md#studio-emr-permissions). Essas permissões concedem ao Studio a capacidade de criar, iniciar, visualizar, acessar e encerrar clusters.
Você pode conectar um cluster do Amazon EMR a um novo JupyterLab notebook diretamente da interface do usuário do Studio ou optar por iniciar a conexão em um notebook de um aplicativo em execução. JupyterLab
**Importante**
Você só pode descobrir e se conectar aos clusters do Amazon EMR JupyterLab e aos aplicativos do Studio Classic que são lançados a partir de espaços privados. Certifique-se de que os clusters do Amazon EMR estejam localizados na mesma AWS região do seu ambiente Studio. Seu JupyterLab espaço deve usar uma versão SageMaker de imagem de distribuição `1.10` ou superior.
## Conecte-se a um cluster do Amazon EMR usando a interface de usuário do Studio
Para se conectar ao seu cluster usando a interface do usuário do Studio ou do Studio Classic, você pode iniciar uma conexão a partir da lista de clusters acessados ou de um notebook no SageMaker Studio ou no Studio Classic. [Listar clusters do Amazon EMR no Studio ou no Studio Classic](discover-emr-clusters.md)
**Para conectar um cluster do Amazon EMR a um novo JupyterLab notebook a partir da interface do usuário do Studio:**
1. No painel esquerdo da interface de usuário do Studio, selecione o nó **Dados** no menu de navegação esquerdo. Navegue até **Aplicações e clusters do Amazon EMR**. Isso abre uma página listando os clusters do Amazon EMR que você pode acessar por meio da guia **Clusters do Amazon EMR**.
**nota**
Se você ou seu administrador tiverem configurado as permissões para permitir o acesso entre contas aos clusters do Amazon EMR, você poderá visualizar uma lista consolidada de clusters em todas as contas às quais você concedeu acesso ao Studio.
1. Selecione um cluster do Amazon EMR que você deseja conectar a um novo caderno e, em seguida, escolha **Anexar ao caderno**. Isso abre uma janela modal exibindo a lista de seus JupyterLab espaços.
1.
+ Selecione o espaço a partir do qual você deseja iniciar um JupyterLab aplicativo e, em seguida, escolha **Abrir caderno**. Isso inicia um JupyterLab aplicativo do espaço escolhido e abre um novo caderno.
**nota**
Os usuários do Studio Classic precisam selecionar uma imagem e um kernel. Para obter uma lista de imagens compatíveis, consulte [Imagens e kernels compatíveis para se conectar a um cluster do Amazon EMR no Studio ou Studio Classic](studio-emr-user-guide.md#studio-notebooks-emr-cluster-connect-kernels) ou [Traga sua própria imagem](studio-emr-user-guide.md#studio-notebooks-emr-byoi).
+ Como alternativa, você pode criar um novo espaço privado escolhendo o botão **Criar novo espaço** na parte superior da janela modal. Insira um nome para o seu espaço e escolha **Criar espaço e abrir o caderno**. Isso cria um espaço privado com o tipo de instância padrão e a imagem SageMaker de distribuição mais recente disponível, inicia um JupyterLab aplicativo e abre um novo notebook.
1. Se o cluster selecionado não usar Kerberos, LDAP ou autenticação da [função de runtime](), o Studio solicitará que você selecione o tipo de credencial. Escolha entre **Autenticação básica HTTP** ou **Sem credenciais** e, em seguida, insira suas credenciais, se aplicável.
Se o cluster selecionado for compatível com funções de runtime, escolha o nome do perfil do IAM que seu cluster do Amazon EMR pode assumir para a execução do trabalho.
**Importante**
Para conectar com sucesso um JupyterLab notebook a um cluster do Amazon EMR que suporta funções de tempo de execução, você deve primeiro associar a lista de funções de tempo de execução ao seu domínio ou perfil de usuário, conforme descrito em. [Configurar perfis de runtime do IAM para acesso ao cluster do Amazon EMR no Studio](studio-notebooks-emr-cluster-rbac.md) A falha na conclusão dessa etapa impedirá que você estabeleça a conexão.
Após a seleção, um comando de conexão preenche a primeira célula do caderno e inicia a conexão com o cluster do Amazon EMR.
Quando a conexão for bem-sucedida, uma mensagem confirmará a conexão e o início da aplicação do Spark.
**Como alternativa, você pode se conectar a um cluster a partir de um notebook Studio Classic JupyterLab ou Studio Classic.**
1. Escolha o botão **Cluster** na parte superior do caderno. Isso abre uma janela modal listando os clusters do Amazon EMR em um estado `Running` que você pode acessar. Você pode ver os clusters `Running` do Amazon EMR na guia **Clusters do Amazon EMR**.
**nota**
Para os usuários do Studio Classic, o **Cluster** só fica visível quando você usa um kernel de [Imagens e kernels compatíveis para se conectar a um cluster do Amazon EMR no Studio ou Studio Classic](studio-emr-user-guide.md#studio-notebooks-emr-cluster-connect-kernels) ou [Traga sua própria imagem](studio-emr-user-guide.md#studio-notebooks-emr-byoi). Se você não conseguir ver o **Cluster** na parte superior do caderno, verifique se o administrador [configurou a capacidade de descoberta dos clusters](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-notebooks-configure-discoverability-emr-cluster.html) e mude para um kernel compatível.
1. Selecione o cluster para o qual deseja se conectar e escolha **Conectar**.
1. Se você configurou os clusters do Amazon EMR para serem compatíveis com os [perfis do IAM de runtime](studio-notebooks-emr-cluster-rbac.md), você pode selecionar seu perfil no menu suspenso **Perfil de execução do Amazon EMR**.
**Importante**
Para conectar com sucesso um JupyterLab notebook a um cluster do Amazon EMR que suporta funções de tempo de execução, você deve primeiro associar a lista de funções de tempo de execução ao seu domínio ou perfil de usuário, conforme descrito em. [Configurar perfis de runtime do IAM para acesso ao cluster do Amazon EMR no Studio](studio-notebooks-emr-cluster-rbac.md) A falha na conclusão dessa etapa impedirá que você estabeleça a conexão.
Caso contrário, se o cluster escolhido não usar Kerberos, LDAP ou autenticação de função de runtime, o Studio ou o Studio Classic solicitará que você selecione o tipo de credencial. Você pode escolher a **autenticação básica HTTP** ou **Sem credencial**.
1. O Studio adiciona e executa um bloco de código em uma célula ativa para estabelecer a conexão. Essa célula contém o comando mágico de conexão para conectar seu caderno à sua aplicação de acordo com o tipo de autenticação.
Quando a conexão for bem-sucedida, uma mensagem confirmará a conexão e o início da aplicação do Spark.
## Conecte-se a um cluster do Amazon EMR usando um comando de conexão
Para estabelecer uma conexão com um cluster do Amazon EMR, você pode executar comandos de conexão em uma célula do caderno.
Ao estabelecer a conexão, você pode se autenticar usando [Kerberos](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-kerberos.html), [Lightweight Directory Access Protocol (LDAP)](https://docs.aws.amazon.com/) ou autenticação de [perfil do IAM de runtime](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-notebooks-emr-cluster-rbac.html). O método de autenticação depende da sua configuração de cluster.
É possível consultar o exemplo [Acesso ao Apache Livy usando um Network Load Balancer em um cluster do Amazon EMR habilitado para Kerberos](https://aws.amazon.com/blogs/big-data/access-apache-livy-using-a-network-load-balancer-on-a-kerberos-enabled-amazon-emr-cluster/) para configurar um cluster do Amazon EMR que usa autenticação do Kerberos. [Como alternativa, você pode explorar os modelos de CloudFormation exemplo usando a autenticação Kerberos ou LDAP no repositório aws-samples/. sagemaker-studio-emr](https://github.com/aws-samples/sagemaker-studio-emr/tree/main/cloudformation/getting_started) GitHub
Se seu administrador habilitou o acesso entre contas, você pode se conectar ao seu cluster do Amazon EMR a partir de um notebook Studio Classic, independentemente de seu aplicativo e cluster Studio Classic residirem na AWS mesma conta ou em contas diferentes.
Para cada um dos seguintes tipos de autenticação, use o comando especificado para se conectar ao cluster a partir do seu caderno do Studio ou Studio Classic:
+ **Kerberos**
Anexe o argumento `--assumable-role-arn` se você precisar de acesso entre contas ao Amazon EMR. Anexe o argumento `--verify-certificate` se você se conectar ao seu cluster com HTTPS.
```
%load_ext sagemaker_studio_analytics_extension.magics
%sm_analytics emr connect --cluster-id cluster_id \
--auth-type Kerberos --language python
[--assumable-role-arn EMR_access_role_ARN ]
[--verify-certificate /home/user/certificateKey.pem]
```
+ **LDAP**
Anexe o argumento `--assumable-role-arn` se você precisar de acesso entre contas ao Amazon EMR. Anexe o argumento `--verify-certificate` se você se conectar ao seu cluster com HTTPS.
```
%load_ext sagemaker_studio_analytics_extension.magics
%sm_analytics emr connect --cluster-id cluster_id \
--auth-type Basic_Access --language python
[--assumable-role-arn EMR_access_role_ARN ]
[--verify-certificate /home/user/certificateKey.pem]
```
+ **NoAuth**
Anexe o argumento `--assumable-role-arn` se você precisar de acesso entre contas ao Amazon EMR. Anexe o argumento `--verify-certificate` se você se conectar ao seu cluster com HTTPS.
```
%load_ext sagemaker_studio_analytics_extension.magics
%sm_analytics emr connect --cluster-id cluster_id \
--auth-type None --language python
[--assumable-role-arn EMR_access_role_ARN ]
[--verify-certificate /home/user/certificateKey.pem]
```
+ **Perfis do IAM de runtime**
Anexe o argumento `--assumable-role-arn` se você precisar de acesso entre contas ao Amazon EMR. Anexe o argumento `--verify-certificate` se você se conectar ao seu cluster com HTTPS.
Para obter mais informações sobre a conexão com um cluster do Amazon EMR usando os perfis do IAM no runtime, consulte [Configurar perfis de runtime do IAM para acesso ao cluster do Amazon EMR no Studio](studio-notebooks-emr-cluster-rbac.md).
```
%load_ext sagemaker_studio_analytics_extension.magics
%sm_analytics emr connect --cluster-id cluster_id \
--auth-type Basic_Access \
--emr-execution-role-arn arn:aws:iam::studio_account_id:role/emr-execution-role-name
[--assumable-role-arn EMR_access_role_ARN]
[--verify-certificate /home/user/certificateKey.pem]
```
## Conecte-se a um cluster do Amazon EMR por HTTPS
Se você configurou seu cluster do Amazon EMR com criptografia de trânsito habilitada e servidor Apache Livy para HTTPS e gostaria que o Studio ou o Studio Classic se comunicassem com o Amazon EMR usando HTTPS, você precisa configurar o Studio ou o Studio Classic para acessar a chave do certificado.
Para certificados autoassinados ou assinados pela Autoridade de Certificação (Certificate Authority, CA) local, você pode fazer isso em duas etapas:
1. Faça download do arquivo PEM do seu certificado para seu sistema de arquivos local usando uma das seguintes opções:
+ Função de upload de arquivos integrada do Jupyter.
+ Uma célula de cadernos.
+ (Somente para usuários do Studio Classic) Um script de configuração do ciclo de vida (LCC).
Para obter informações sobre como usar um script de LCC, consulte [Personalizar uma instância de cadernos usando um script de configuração de ciclo de vida](https://docs.aws.amazon.com/sagemaker/latest/dg/notebook-lifecycle-config.html)
1. Ative a validação do certificado fornecendo o caminho para seu certificado no argumento `--verify-certificate` do seu comando de conexão.
```
%sm_analytics emr connect --cluster-id cluster_id \
--verify-certificate /home/user/certificateKey.pem ...
```
Para certificados públicos emitidos pela CA, defina a validação do certificado definindo o parâmetro `--verify-certificate` como `true`.
Como alternativa, você pode desativar a validação do certificado definindo o parâmetro `--verify-certificate` como `false`.
Você pode encontrar a lista de comandos de conexão disponíveis para um cluster do Amazon EMR em [Conecte-se a um cluster do Amazon EMR usando um comando de conexão](#connect-emr-clusters-manually).
# Encerrar um cluster do Amazon EMR no Studio ou Studio Classic
O procedimento a seguir mostra como encerrar um cluster do Amazon EMR em um caderno do Studio ou Studio Classic.
**Para encerrar um cluster em um estado `Running`, navegue até a lista de clusters disponíveis do Amazon EMR.**
1. Na interface de usuário do Studio, role para baixo até o nó **Dados** no menu de navegação à esquerda.
1. Navegue até o nó **Clusters do EMR**. Isso abre uma página listando os clusters do Amazon EMR aos quais você pode acessar.
1. Selecione o nome do cluster que você deseja encerrar e, em seguida, escolha **Encerrar**.
1. Isso abre uma janela de confirmação informando que qualquer trabalho ou dados pendentes em seu cluster serão perdidos permanentemente após o encerramento. Confirme escolhendo **Encerrar** novamente.
# Acesse a interface de usuário do Spark no Studio ou no Studio Classic
As seções a seguir fornecem instruções para acessar a interface do usuário do Spark a partir dos notebooks SageMaker AI Studio ou Studio Classic. A interface de usuário do Spark permite monitorar e depurar seus trabalhos do Spark enviados para execução no Amazon EMR a partir dos cadernos do Studio ou Studio Classic. O tunelamento SSH e o pré-assinado URLs são duas formas de acessar a interface do usuário do Spark.
## Configure o encapsulamento SSH para acesso à IU do Spark
Para configurar o encapsulamento SSH para acessar a IU do Spark, siga uma das duas opções nesta seção.
Opções para configurar o encapsulamento SSH:
+ [Opção 1: configurar um encapsulamento SSH ao nó principal usando o encaminhamento de portas locais](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-ssh-tunnel-local.html)
+ [Opção 2, parte 1: configurar um encapsulamento SSH para o nó principal usando o encaminhamento de portas dinâmicas](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-ssh-tunnel.html)
[Opção 2, parte 2: definiras configurações de proxy para visualizar sites hospedados no nó principal](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-connect-master-node-proxy.html)
Para obter mais informações sobre a visualização de interfaces Web no Amazon EMR, consulte [Visualizar interfaces hospedadas nos clusters do Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-web-interfaces.html). Você também pode visitar o console do Amazon EMR para ter acesso à IU do Spark.
**nota**
Você pode configurar um túnel SSH mesmo que os pré-assinados não URLs estejam disponíveis para você.
## Pré-assinado URLs
Para criar um clique URLs que possa acessar a interface do usuário do Spark no Amazon EMR a partir dos notebooks SageMaker Studio ou Studio Classic, você deve habilitar as seguintes permissões do IAM. Escolha a opção que se aplica a você:
+ **Para clusters do Amazon EMR que estão na mesma conta do notebook SageMaker Studio ou Studio Classic: adicione as seguintes permissões à função de execução do IAM do SageMaker Studio ou do Studio Classic.**
+ **Para clusters do Amazon EMR que estão em uma conta diferente (não no notebook SageMaker Studio ou Studio Classic): adicione as seguintes permissões à função entre contas para a qual você criou. [Listar clusters do Amazon EMR no Studio ou no Studio Classic](discover-emr-clusters.md)**
**nota**
Você pode acessar o pré-assinado URLs do console nas seguintes regiões:
Região Leste dos EUA (Norte da Virgínia)
Região Oeste dos EUA (Norte da Califórnia)
Região Canadá (Central)
Região Europa (Frankfurt)
Região Europa (Estocolmo)
Região Europa (Irlanda)
Região Europa (Londres)
Região Europa (Paris)
Região Ásia-Pacífico (Tóquio)
Região Ásia-Pacífico (Seul)
Ásia-Pacífico (Sydney)
Região Ásia-Pacífico (Mumbai)
Região Ásia-Pacífico (Singapura)
América do Sul (São Paulo)
A política a seguir dá acesso a presignados URLs para sua função de execução.
```
{
"Sid": "AllowPresignedUrl",
"Effect": "Allow",
"Action": [
"elasticmapreduce:DescribeCluster",
"elasticmapreduce:ListInstanceGroups",
"elasticmapreduce:CreatePersistentAppUI",
"elasticmapreduce:DescribePersistentAppUI",
"elasticmapreduce:GetPersistentAppUIPresignedURL",
"elasticmapreduce:GetOnClusterAppUIPresignedURL"
],
"Resource": [
"arn:aws:elasticmapreduce:region:account-id:cluster/*"
]
}
```
# Blogs e guias técnicos
Os blogs a seguir usam um estudo de caso de predição de sentimentos para uma resenha de filme para ilustrar o processo de execução de um fluxo de trabalho completo de machine learning. Isso inclui preparação de dados, monitoramento de trabalhos do Spark e treinamento e implantação de modelo de ML para obter predições diretamente a partir do caderno do Studio ou Studio Classic.
+ [Crie e gerencie clusters do Amazon EMR a partir do SageMaker Studio ou do Studio Classic para executar cargas de trabalho interativas do Spark e](https://aws.amazon.com/blogs/machine-learning/part-1-create-and-manage-amazon-emr-clusters-from-sagemaker-studio-to-run-interactive-spark-and-ml-workloads/) do ML.
+ Para estender o caso de uso para uma configuração entre contas em que o SageMaker Studio ou o Studio Classic e seu cluster do Amazon EMR são implantados em contas AWS separadas, [consulte Criar e gerenciar clusters do Amazon EMR a SageMaker partir do Studio ou do Studio Classic para executar cargas de trabalho interativas do Spark](https://aws.amazon.com/blogs/machine-learning/part-2-create-and-manage-amazon-emr-clusters-from-sagemaker-studio-to-run-interactive-spark-and-ml-workloads/) e do ML - Parte 2.
Consulte também:
+ Um passo a passo da configuração do [Acessar o Apache Livy usando um Network Load Balancer em um cluster Amazon EMR habilitado para Kerberos](https://aws.amazon.com/blogs/big-data/access-apache-livy-using-a-network-load-balancer-on-a-kerberos-enabled-amazon-emr-cluster/).
+ AWS whitepapers sobre as [melhores práticas do SageMaker Studio ou do Studio Classic](https://docs.aws.amazon.com/whitepapers/latest/sagemaker-studio-admin-best-practices/sagemaker-studio-admin-best-practices.html).
# Solução de problemas
Ao trabalhar com clusters do Amazon EMR a partir de cadernos do Studio ou Studio Classic, você pode encontrar vários problemas ou desafios em potencial durante o processo de conexão ou uso. Para ajudar a solucionar esses erros, esta seção fornece orientação sobre problemas comuns que podem surgir.
A seguir estão os erros comuns que podem ocorrer ao conectar ou usar clusters do Amazon EMR nos cadernos do Studio ou Studio Classic.
## Solucione problemas de conexões do Livy interrompidas ou falhando
A seguir estão os problemas de conectividade do Livy que podem ocorrer ao usar clusters do Amazon EMR nos cadernos do Studio ou Studio Classic.
+ **Seu cluster do Amazon EMR encontrou um out-of-memory erro.**
Um possível motivo para uma conexão do Livy `sparkmagic` travar ou falhar é se seu cluster do Amazon EMR encontrou um erro. out-of-memory
Por padrão, o parâmetro de configuração Java do driver Apache Spark, `spark.driver.defaultJavaOptions`, está definido como `-XX:OnOutOfMemoryError='kill -9 %p'`. Isso significa que a ação padrão tomada quando o programa do driver encontra um `OutOfMemoryError` é encerrar o programa do driver enviando um sinal SIGKILL. Quando o driver Apache Spark é encerrado, qualquer conexão Livy via `sparkmagic` que depende desse driver para ou falha. Isso ocorre porque o driver do Spark é responsável por gerenciar os recursos da aplicação Spark, incluindo o agendamento e a execução de tarefas. Sem o driver, a aplicação do Spark não pode funcionar e qualquer tentativa de interagir com ele falha.
Se você suspeitar que o cluster Spark está com problemas de memória, você pode verificar os logs do [Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-manage-view-web-log-files.html). Os contêineres eliminados devido a out-of-memory erros geralmente saem com um código de`137`. Nesses casos, você precisa reiniciar a aplicação do Spark e estabelecer uma nova conexão Livy para retomar a interação com o cluster do Spark.
Você pode consultar o artigo da base de conhecimento [Como resolvo o erro “Contêiner eliminado pelo YARN por exceder os limites de memória” no Spark no Amazon](https://repost.aws/knowledge-center/emr-spark-yarn-memory-limit) EMR? continue AWS re:Post para aprender sobre várias estratégias e parâmetros que podem ser usados para resolver um out-of-memory problema.
Recomendamos revisar os guias de práticas recomendadas do [Amazon EMR para obter as práticas recomendadas](https://aws.github.io/aws-emr-best-practices/) e orientações de ajuste sobre a execução de workloads do Apache Spark em seus clusters do Amazon EMR.
+ **A sessão do Livy expira ao se conectar a um cluster do Amazon EMR pela primeira vez**.
Quando você se conecta inicialmente a um cluster do Amazon EMR usando [sagemaker-studio-analytics-extension](https://pypi.org/project/sagemaker-studio-analytics-extension/), que permite a conexão com um cluster remoto do Spark (Amazon EMR) por meio da [SparkMagic](https://github.com/jupyter-incubator/sparkmagic)biblioteca usando o [Apache Livy](https://livy.apache.org/), você pode encontrar um erro de tempo limite de conexão:
`An error was encountered: Session 0 did not start up in 60 seconds.`
Se o cluster do Amazon EMR exigir a inicialização de uma aplicação do Spark ao estabelecer uma conexão, há uma chance maior de ver erros de tempo limite de conexão.
Para reduzir as chances de erros de tempos limite ao se conectar a um cluster do Amazon EMR usando o Livy via extensão de analytics, a versão `sagemaker-studio-analytics-extension` `0.0.19` e posterior, substitua o tempo limite da sessão padronizado do servidor para `120` segundos em vez do padrão `sparkmagic` de `60` segundos.
Recomendamos atualizar sua extensão `0.0.18` e anterior, executando o seguinte comando de atualização:
```
pip install --upgrade sagemaker-studio-analytics-extension
```
Lembre-se de que, ao fornecer uma configuração de tempo limite personalizada no `sparkmagic`, o `sagemaker-studio-analytics-extension` respeitará essa substituição. No entanto, definir o tempo limite da sessão em `60` segundos aciona automaticamente o tempo limite da sessão padronizado da sessão do servidor de `120` segundos depois no `sagemaker-studio-analytics-extension`.
# Preparação de dados usando sessões AWS Glue interativas
As [sessões interativas do AWS Glue](https://docs.aws.amazon.com/glue/latest/dg/interactive-sessions-overview.html) são um serviço sem servidor ao qual você pode recorrer para coletar, transformar, limpar e preparar dados para armazenamento em seus data lakes e pipelines de dados. As sessões interativas do AWS Glue fornecem um ambiente de runtime do Apache Spark sob demanda e sem servidor que você pode inicializar em segundos em uma unidade de processamento de dados (DPU) dedicada sem precisar provisionar e gerenciar uma infraestrutura complexa de clusters de computação. Após a inicialização, você pode navegar pelo catálogo de AWS Glue dados, executar grandes consultas, acessar dados controlados e analisar e preparar dados de forma interativa usando o Spark, diretamente em seus notebooks Studio ou Studio Classic. AWS Lake Formation Em seguida, você pode usar os dados preparados para treinar, ajustar e implantar modelos usando as ferramentas de ML criadas especificamente no SageMaker Studio ou no Studio Classic. Você deve considerar as sessões AWS Glue interativas para suas cargas de trabalho de preparação de dados quando quiser um serviço Spark sem servidor com controle moderado de configurabilidade e flexibilidade.
Você pode iniciar uma sessão AWS Glue interativa iniciando um JupyterLab notebook no Studio ou no Studio Classic. Ao iniciar seu caderno, escolha o kernel integrado `Glue PySpark and Ray` ou `Glue Spark`. Isso inicia automaticamente uma sessão interativa sem servidor do Spark. Não é necessário provisionar nem gerenciar nenhum cluster ou infraestrutura de computação. Após a inicialização, você pode explorar e interagir com seus dados a partir dos seus cadernos do Studio ou Studio Classic.
Antes de iniciar sua sessão AWS Glue interativa no Studio ou no Studio Classic, você precisa definir as funções e políticas apropriadas. Além disso, talvez seja necessário dar acesso a recursos adicionais, como um bucket de armazenamento do Amazon S3. Para ver mais informações sobre as políticas do IAM necessárias, consulte [Permissões para sessões AWS Glue interativas no Studio ou no Studio Classic](getting-started-glue-sm.md#glue-sm-iam).
O Studio e o Studio Classic fornecem uma configuração padrão para sua sessão AWS Glue interativa, no entanto, você pode usar o catálogo completo AWS Glue de comandos mágicos do Jupyter para personalizar ainda mais seu ambiente. Para obter informações sobre as magias padrão e adicionais do Jupyter que você pode usar em sua sessão AWS Glue interativa, consulte. [Configure sua sessão AWS Glue interativa no Studio ou no Studio Classic](getting-started-glue-sm.md#glue-sm-magics)
+ Para usuários do Studio Classic que iniciam uma sessão AWS Glue interativa, eles podem selecionar entre as seguintes imagens e kernels:
+ Imagens: `SparkAnalytics 1.0`, `SparkAnalytics 2.0`
+ Kernel: `Glue Python [PySpark and Ray]` e `Glue Spark`
+ Para usuários do Studio, use a [imagem SageMaker de distribuição](https://github.com/aws/sagemaker-distribution) padrão e selecione um `Glue Python [PySpark and Ray]` ou um `Glue Spark` kernel.
# Comece com sessões AWS Glue interativas
Neste guia, você aprende como iniciar uma sessão AWS Glue interativa no SageMaker AI Studio Classic e gerenciar seu ambiente com as magias do Jupyter.
## Permissões para sessões AWS Glue interativas no Studio ou no Studio Classic
Esta seção lista as políticas necessárias para executar sessões AWS Glue interativas no Studio ou no Studio Classic e explica como configurá-las. Em particular, detalha como:
+ Vincule a política `AwsGlueSessionUserRestrictedServiceRole` gerenciada à sua função de execução de SageMaker IA.
+ Crie uma política personalizada em linha em sua função de execução de SageMaker IA.
+ Modifique a relação de confiança da sua função de execução de SageMaker IA.
**Para anexar a política gerenciada `AwsGlueSessionUserRestrictedServiceRole` ao seu perfil de execução**
1. Abra o [console do IAM](https://console.aws.amazon.com/iam/).
1. Selecione **Funções** no painel do lado esquerdo.
1. Encontre o perfil de execução do Studio Classic usado pelo seu perfil de usuário. Para obter informações sobre como visualizar um perfil de usuário, consulte [Visualizar perfis de usuário em um domínio](domain-user-profile-view.md).
1. Escolha o nome do perfil para acessar a página de resumo do perfil.
1. Na guia **Permissões**, selecione **Anexar políticas** no menu suspenso **Adicionar permissões**.
1. Marque a caixa de seleção ao lado da política gerenciada `AwsGlueSessionUserRestrictedServiceRole`.
1. Escolha **Anexar políticas**.
A página de resumo mostra as políticas gerenciadas recém-adicionadas.
**Criar uma política personalizada em linha no seu perfil de execução**
1. Selecione **Criar política em linha** no menu suspenso **Adicionar permissões**.
1. Selecione a guia **JSON**.
1. Copie e cole na política a seguir.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "uniqueStatementId",
"Effect": "Allow",
"Action": [
"iam:GetRole",
"iam:PassRole",
"sts:GetCallerIdentity"
],
"Resource": "arn:aws:iam::*:role/GlueServiceRole*"
}
]
}
```
------
1. Escolha **Revisar política**.
1. Digite um **Nome** e escolha **Criar política**.
A página de resumo mostra as políticas personalizadas recém-adicionadas.
**Para modificar a relação de confiança do seu perfil de execução**
1. Selecione a guia **Relações de confiança**.
1. Escolha **Editar política de confiança**.
1. Copie e cole na política a seguir.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"glue.amazonaws.com",
"sagemaker.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Escolha **Atualizar política**.
Você pode adicionar outras funções e políticas se precisar acessar outros recursos AWS . Para obter uma descrição das funções e políticas adicionais que você pode incluir, consulte as [sessões interativas com o IAM](https://docs.aws.amazon.com/glue/latest/dg/glue-is-security.html) na AWS Glue documentação.
## Propagação de tags
As tags são comumente usadas para rastrear e alocar custos, controlar o acesso à sua sessão, isolar seus recursos e muito mais. Para saber mais sobre como adicionar metadados aos seus recursos AWS usando tags ou para obter detalhes sobre casos de uso comuns, consulte [Mais informações](#more-information).
Você pode ativar a propagação automática de AWS tags para novas sessões AWS Glue interativas criadas na interface do usuário do Studio ou do Studio Classic. Quando uma sessão AWS Glue interativa é criada a partir do Studio ou do Studio Classic, todas as [tags definidas pelo](https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/custom-tags.html) usuário anexadas ao perfil do usuário ou ao espaço compartilhado são transferidas para a nova sessão AWS Glue interativa. Além disso, o Studio e o Studio Classic adicionam automaticamente duas tags internas AWS geradas ((`sagemaker:user-profile-arn`e`sagemaker:domain-arn`) ou (`sagemaker:shared-space-arn`e`sagemaker:domain-arn`)) às novas sessões AWS Glue interativas criadas a partir da interface do usuário. Você pode usar essas tags para agregar custos em domínios, perfis de usuário ou espaços individuais.
### Habilitar propagação de tags
Para ativar a propagação automática de tags para novas sessões AWS Glue interativas, defina as seguintes permissões para sua função de execução de SageMaker IA e a função do IAM associada à sua AWS Glue sessão:
**nota**
Por padrão, a função associada à sessão AWS Glue interativa é a mesma que a função de execução da SageMaker IA. Você pode especificar uma função de execução diferente para a sessão AWS Glue interativa usando o comando `%iam_role` mágico. Para obter informações sobre os comandos mágicos do Jupyter disponíveis para configurar sessões interativas do AWS Glue , consulte [Configure sua sessão AWS Glue interativa no Studio ou no Studio Classic](#glue-sm-magics).
+ *Em sua função de execução de SageMaker IA*: crie uma nova política embutida e cole o seguinte arquivo JSON. A política concede à função de execução permissão para descrever (`DescribeUserProfile``DescribeSpace`,,`DescribeDomain`) e listar as tags (`ListTag`) definidas nos perfis de usuário, espaços compartilhados e domínio de SageMaker IA.
```
{
"Effect": "Allow",
"Action": [
"sagemaker:ListTags"
],
"Resource": [
"arn:aws:sagemaker:*:*:user-profile/*",
"arn:aws:sagemaker:*:*:space/*"
]
},
{
"Effect": "Allow",
"Action": [
"sagemaker:DescribeUserProfile"
],
"Resource": [
"arn:aws:sagemaker:*:*:user-profile/*"
]
},
{
"Effect": "Allow",
"Action": [
"sagemaker:DescribeSpace"
],
"Resource": [
"arn:aws:sagemaker:*:*:space/*"
]
}
{
"Effect": "Allow",
"Action": [
"sagemaker:DescribeDomain"
],
"Resource": [
"arn:aws:sagemaker:*:*:domain/*"
]
}
```
+ *Na função de IAM da sua sessão AWS Glue *: Crie uma nova política em linha e cole o arquivo JSON a seguir. A política concede permissão à sua função para anexar tags (`TagResource`) à sua sessão ou recuperar sua lista de tags (`GetTags`).
```
{
"Effect": "Allow",
"Action": [
"glue:TagResource",
"glue:GetTags"
],
"Resource": [
"arn:aws:glue:*:*:session/*"
]
}
```
**nota**
As falhas que ocorrem ao aplicar essas permissões não impedem a criação de sessões AWS Glue interativas. Você pode encontrar detalhes sobre o motivo da falha nos [CloudWatch](https://docs.aws.amazon.com//sagemaker/latest/dg/monitoring-cloudwatch.html)registros do Studio ou do Studio Classic.
Você deve reiniciar o kernel da sua sessão AWS Glue interativa para propagar a atualização do valor de uma tag.
É importante observar os seguintes pontos:
+ Depois que uma tag é anexada a uma sessão, ela não pode ser removida por propagação.
Você pode remover tags de uma sessão AWS Glue interativa diretamente por meio do AWS CLI, da AWS Glue API ou do [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/). Por exemplo, usando o AWS CLI, você pode remover uma tag fornecendo o ARN da sessão e as chaves de tag que você deseja remover da seguinte forma:
```
aws glue untag-resource \
--resource-arn arn:aws:glue:region:account-id:session:session-name \
--tags-to-remove tag-key1,tag-key2
```
+ O Studio e o Studio Classic adicionam duas tags internas AWS geradas ((`sagemaker:user-profile-arn`e`sagemaker:domain-arn`) ou (`sagemaker:shared-space-arn`e`sagemaker:domain-arn`)) às novas sessões AWS Glue interativas criadas a partir de sua interface de usuário. Essas tags contam contra o limite de 50 tags definido em todos os AWS recursos. Tanto `sagemaker:user-profile-arn` quanto `sagemaker:shared-space-arn` contêm o ID de domínio ao qual pertencem.
+ As chaves de tags que começam com `aws:``AWS:`,, ou qualquer combinação de letras maiúsculas e minúsculas como prefixo para chaves não são propagadas e são reservadas para uso. AWS
### Mais informações
Para obter mais informações sobre marcação, consulte os recursos a seguir.
+ Para saber mais sobre como adicionar metadados aos seus AWS recursos com marcação, consulte Como [marcar AWS](https://docs.aws.amazon.com/tag-editor/latest/userguide/tagging.html) recursos.
+ Para obter informações sobre o controle de custos usando tags, consulte [Análise de custos](https://docs.aws.amazon.com/whitepapers/latest/sagemaker-studio-admin-best-practices/cost-attribution.html) nas práticas recomendadas de administração do Studio.
+ Para obter informações sobre como controlar o acesso AWS Glue com base em chaves de tag, consulte [ABAC com AWS Glue](glue/latest/dg/security_iam_service-with-iam.html#security_iam_service-with-iam-tags).
## Inicie sua sessão AWS Glue interativa no Studio ou no Studio Classic
Depois de criar as funções, as políticas e o domínio de SageMaker IA, você pode iniciar sua sessão AWS Glue interativa no Studio ou no Studio Classic.
1. Faça login no console de SageMaker IA em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. No painel de navegação à esquerda, escolha **Studio**.
1. Na página inicial do Studio, selecione o domínio e o perfil de usuário para iniciar o Studio.
1. Escolha **Open Studio** e inicie um aplicativo JupyterLab ou Studio Classic.
1. Na visualização do Jupyter, escolha **Arquivo**, depois **Novo** e, em seguida, **Cadernos.**
1. **Para usuários do Studio Classic: no menu suspenso **Imagem**, selecione **SparkAnalytics 1.0 ou SparkAnalytics 2.0**.** No menu suspenso do **kernel**, selecione Glue **Spark ou Glue PySpark ** **Python [**and Ray]. Escolha **Selecionar**.
Para usuários do Studio, selecione um kernel **Glue Spark** ou **Glue Python PySpark [and** Ray]
1. (opcional) Use mágicas do Jupyter para personalizar seu ambiente. Para obter mais informações sobre como encerrar uma , consulte [Configure sua sessão AWS Glue interativa no Studio ou no Studio Classic](#glue-sm-magics).
1. Comece a escrever seus scripts de processamento de dados do Spark. O [caderno](https://github.com/aws/amazon-sagemaker-examples/blob/main/use-cases/pyspark_etl_and_training/pyspark-etl-training.ipynb) a seguir mostra um end-to-end fluxo de trabalho para ETL em um grande conjunto de dados usando uma sessão AWS Glue interativa, análise exploratória de dados, pré-processamento de dados e, finalmente, treinamento de um modelo nos dados processados com IA. SageMaker
## Configure sua sessão AWS Glue interativa no Studio ou no Studio Classic
**nota**
Todas as configurações mágicas são transferidas para as sessões subsequentes durante a vida útil do AWS Glue kernel.
Você pode usar as magias do Jupyter em sua sessão AWS Glue interativa para modificar seus parâmetros de sessão e configuração. Magics são comandos curtos prefixados com `%` no início das células Jupyter que propiciam uma maneira rápida e fácil de ajudá-lo a controlar seu ambiente. Em sua sessão AWS Glue interativa, as seguintes magias são definidas para você por padrão:
| Magia | Valor padrão |
| --- | --- |
| %glue\$1version | 3.0 |
| %iam\$1role | *execution role attached to your SageMaker AI domain* |
| %region | sua região |
É possível usar mágicas para personalizar ainda mais seu ambiente. Por exemplo, se você quiser alterar o número de operadores alocados para seu trabalho do padrão de cinco para 10, você pode especificar `%number_of_workers 10`. Se quiser configurar sua sessão para parar após 10 minutos de tempo ocioso em vez do 2880 padrão, você pode especificar `%idle_timeout 10`.
Todas as magias de Jupyter atualmente disponíveis também AWS Glue estão disponíveis no Studio ou no Studio Classic. Para ver a lista completa das AWS Glue mágicas disponíveis, consulte [Configuração de sessões AWS Glue interativas para notebooks Jupyter](https://docs.aws.amazon.com/glue/latest/dg/interactive-sessions-magics.html) e Studio. AWS Glue
# AWS Glue preços de sessões interativas
Ao usar sessões AWS Glue interativas nos notebooks Studio ou Studio Classic, você é cobrado separadamente pelo uso de recursos nos AWS Glue notebooks Studio.
AWS cobranças por sessões AWS Glue interativas com base no tempo em que a sessão está ativa e no número de unidades de processamento de dados (DPU) usadas. É cobrada uma taxa horária pelo número de pessoas DPUs usadas para executar suas cargas de trabalho, cobrada em incrementos de um segundo. AWS Glue as sessões interativas atribuem um padrão de cinco DPUs e exigem um mínimo de duas DPUs. Também há um período mínimo para cobrança de um minuto para cada sessão interativa. Para ver as AWS Glue tarifas e exemplos de preços, ou para estimar seus custos usando a Calculadora de AWS preços, consulte [AWS Glue preços](https://aws.amazon.com/glue/pricing).
Seu caderno do Studio ou Studio Classic é executado em uma instância do Amazon EC2, e a cobrança é feita pelo tipo de instância escolhido, com base na duração do uso. O Studio Classic atribui a você o tipo de instância padrão da EC2 `ml-t3-medium` quando você seleciona a imagem `SparkAnalytics` e o kernel associado. Você pode alterar o tipo de instância do seu caderno do Studio Classic de acordo com seu workload. Para obter informações sobre os preços do Studio e do Studio Classic, consulte [ SageMaker Preços da Amazon](https://aws.amazon.com/sagemaker/pricing).
# Prepare dados de ML com o Amazon SageMaker Data Wrangler
**Importante**
O Amazon SageMaker Data Wrangler foi integrado ao Amazon SageMaker Canvas. Na nova experiência do Data Wrangler no SageMaker Canvas, você pode usar uma interface de linguagem natural para explorar e transformar seus dados, além da interface visual. Para obter mais informações sobre o Data Wrangler no SageMaker Canvas, consulte. [preparação de dados](canvas-data-prep.md)
O Amazon SageMaker Data Wrangler (Data Wrangler) é um recurso do Amazon SageMaker Studio Classic que fornece uma end-to-end solução para importar, preparar, transformar, caracterizar e analisar dados. Você pode integrar um fluxo de preparação de dados do Data Wrangler aos seus fluxos de trabalho de machine learning (ML) para simplificar e agilizar o pré-processamento de dados e a engenharia de atributos usando pouca ou nenhuma codificação. Você também pode adicionar seus próprios scripts e transformações em Python para personalizar os fluxos de trabalho.
O Data Wrangler fornece as seguintes funcionalidades principais para ajudá-lo a analisar e preparar dados para aplicações de machine learning:
+ **Importar** — Conecte-se e importe dados do Amazon Simple Storage Service (Amazon S3), Amazon Athena (Athena), Amazon Redshift, Snowflake e Databricks.
+ **Fluxo de dados**: crie um fluxo de dados para definir uma série de etapas de preparação de dados de ML. Você pode usar um fluxo para combinar conjuntos de dados de diferentes fontes de dados, identificar o número e os tipos de transformações que você deseja aplicar aos conjuntos de dados e definir um fluxo de trabalho de preparação de dados que possa ser integrado a um pipeline de ML.
+ **Transforme**: limpe e transforme seu conjunto de dados usando *transformações* padrão, como ferramentas de formatação de dados numéricos, vetoriais e de sequência de caracteres. Destaque seus dados usando transformações como texto, date/time incorporação e codificação categórica.
+ **Gere insights de dados**: verifique automaticamente a qualidade dos dados e detecte anomalias em seus dados com o Data Wrangler Data Insights e o Quality Report.
+ **Analise**: analise os atributos do seu conjunto de dados em qualquer ponto do fluxo. O Data Wrangler inclui ferramentas de visualização de dados integradas, como gráficos de dispersão e histogramas, bem como ferramentas de análise de dados, como análise de vazamento de alvos e modelagem rápida para entender a correlação de atributos.
+ **Exportar**: exporte seu fluxo de trabalho de preparação de dados para um local diferente. Estes são locais de exemplo:
+ Bucket do Amazon Simple Storage Service (Amazon S3)
+ Amazon SageMaker Pipelines — Use Pipelines para automatizar a implantação do modelo. Você pode exportar os dados que você transformou diretamente para os pipelines.
+ Amazon SageMaker Feature Store — Armazene os recursos e seus dados em uma loja centralizada.
+ Script Python: armazene os dados e suas transformações em um script Python para seus fluxos de trabalho personalizados.
Para começar a usar o Data Wrangler, consulte [Conceitos básicos do Data Wrangler](data-wrangler-getting-started.md).
**Importante**
O Data Wrangler não é mais compatível com a versão 1 do Jupyter Lab (). JL1 Para acessar os atributos e atualizações mais recentes, atualize para a versão 3 do Jupyter Lab. Para obter mais informações sobre a atualização, consulte [Visualize e atualize a JupyterLab versão de um aplicativo no console](studio-jl.md#studio-jl-view).
**Importante**
As informações e os procedimentos neste guia usam a versão mais recente do Amazon SageMaker Studio Classic. Para obter mais informações sobre como atualizar o Studio Classic para a versão mais recente, consulte [Visão geral da interface do usuário do Amazon SageMaker Studio Classic](studio-ui.md).
Você deve usar a versão 1.3.0 ou posterior do Studio Classic. Use o procedimento a seguir para abrir o Amazon SageMaker Studio Classic e ver qual versão você está executando.
Para abrir o Studio Classic e verificar sua versão, consulte o procedimento a seguir.
1. Use as etapas [Pré-requisitos](data-wrangler-getting-started.md#data-wrangler-getting-started-prerequisite) para acessar o Data Wrangler por meio do Amazon SageMaker Studio Classic.
1. Ao lado do usuário que você deseja usar para executar o Studio Classic, selecione **Executar aplicação**.
1. Escolha **Studio**.
1. Assim que o Studio Classic for carregado, selecione **Arquivo** e, em seguida, **Novo** e, depois, **Terminal**.
![\[As opções do menu de contexto do Studio Classic descritas na etapa 4.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/terminal.png)
1. Após a inicialização do Studio Classic, selecione **Arquivo**, depois **Novo** e, em seguida, **Terminal**.
1. Digite `cat /opt/conda/share/jupyter/lab/staging/yarn.lock | grep -A 1 "@amzn/sagemaker-ui-data-prep-plugin@"` para registrar a versão da sua instância do Studio Classic. Você deve ter a versão 1.3.0 do Studio Classic para usar o Snowflake.
![\[Uma janela de terminal aberta no Studio Classic com o comando da etapa 6 copiado e colado.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/cat-command.png)
Você pode atualizar o Amazon SageMaker Studio Classic de dentro do Console de gerenciamento da AWS. Para obter mais informações sobre como atualizar o Studio Classic, consulte [Visão geral da interface do usuário do Amazon SageMaker Studio Classic](studio-ui.md).
**Topics**
+ [Conceitos básicos do Data Wrangler](data-wrangler-getting-started.md)
+ [Importar](data-wrangler-import.md)
+ [Crie e use um fluxo do Data Wrangler](data-wrangler-data-flow.md)
+ [Obtenha insights sobre dados e qualidade dos dados](data-wrangler-data-insights.md)
+ [Treine modelos automaticamente em seu fluxo de dados](data-wrangler-autopilot.md)
+ [Transformar dados](data-wrangler-transform.md)
+ [Analisar e visualizar](data-wrangler-analyses.md)
+ [Reutilização de fluxos de dados para diferentes conjuntos de dados](data-wrangler-parameterize.md)
+ [Exportar](data-wrangler-data-export.md)
+ [Use um widget interativo de preparação de dados em um notebook Amazon SageMaker Studio Classic para obter insights de dados](data-wrangler-interactively-prepare-data-notebook.md)
+ [Segurança e permissões](data-wrangler-security.md)
+ [Notas da versão](data-wrangler-release-notes.md)
+ [Solução de problemas](data-wrangler-trouble-shooting.md)
+ [Aumente o limite de instâncias do Amazon EC2](data-wrangler-increase-instance-limit.md)
+ [Atualizar o Data Wrangler](data-wrangler-update.md)
+ [Encerrando o Data Wrangler](data-wrangler-shut-down.md)
# Conceitos básicos do Data Wrangler
O Amazon SageMaker Data Wrangler é um recurso do Amazon SageMaker Studio Classic. Use esta seção para saber como acessar e começar a usar o Data Wrangler. Faça o seguinte:
1. Conclua cada etapa em [Pré-requisitos](#data-wrangler-getting-started-prerequisite).
1. Siga o procedimento em [Acesse o Data Wrangler](#data-wrangler-getting-started-access) para começar a usar o Data Wrangler.
## Pré-requisitos
Para usar o Data Wrangler, é necessário concluir os pré-requisitos a seguir.
1. Para usar o Data Wrangler, é necessário acessar uma instância do Amazon Elastic Compute Cloud (Amazon EC2). Para obter mais informações sobre as instâncias do Amazon EC2 que você pode usar, consulte [Instâncias](data-wrangler-data-flow.md#data-wrangler-data-flow-instances). Para saber como visualizar suas cotas e, se necessário, solicitar um aumento de cota, consulte [Service Quotas da AWS](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html).
1. Configure as permissões obrigatórias descritas em [Segurança e permissões](data-wrangler-security.md).
1. Se sua organização estiver usando um firewall que bloqueia o tráfego da Internet, você deverá ter acesso ao seguinte URLs:
+ `https://ui.prod-1.data-wrangler.sagemaker.aws/`
+ `https://ui.prod-2.data-wrangler.sagemaker.aws/`
+ `https://ui.prod-3.data-wrangler.sagemaker.aws/`
+ `https://ui.prod-4.data-wrangler.sagemaker.aws/`
Para usar o Data Wrangler, você precisa de uma instância ativa do Studio Classic. Para saber como iniciar uma nova instância, consulte [Visão geral do domínio Amazon SageMaker AI](gs-studio-onboard.md). Quando sua instância do Studio Classic estiver com o status **Pronto**, use as instruções em [Acesse o Data Wrangler](#data-wrangler-getting-started-access).
## Acesse o Data Wrangler
O procedimento a seguir pressupõe que você já concluiu os [Pré-requisitos](#data-wrangler-getting-started-prerequisite).
Para acessar o Data Wrangler no Studio Classic, faça o seguinte:
1. Faça login no Studio Classic. Para obter mais informações, consulte [Visão geral do domínio Amazon SageMaker AI](gs-studio-onboard.md).
1. Escolha **Studio**.
1. Escolha **Iniciar aplicação**.
1. Na lista suspensa, selecione **Studio**.
1. Escolha o ícone Início.
1. Escolha **Dados**.
1. Escolha **Data Wrangler**.
1. Você também pode criar um fluxo do Data Wrangler fazendo o seguinte:
1. Na barra de navegação superior, selecione **Arquivo**.
1. Selecione **Novo**.
1. Selecione **Fluxo do Data Wrangler**.
![\[Aba “Início” do console do Studio Classic.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/new-flow-file-menu.png)
1. (Opcional) Renomeie o novo diretório e o arquivo .flow.
1. Ao criar um novo arquivo .flow no Studio Classic, você pode ver um carrossel que apresenta o Data Wrangler.
**Isso pode levar alguns minutos.**
Essa mensagem persiste enquanto o **KernelGateway**aplicativo na sua página de **detalhes do usuário** estiver **pendente**. Para ver o status desse aplicativo, no console de SageMaker IA na página do **Amazon SageMaker Studio Classic**, selecione o nome do usuário que você está usando para acessar o Studio Classic. Na página **Detalhes do usuário**, você vê um **KernelGateway**aplicativo em **Aplicativos**. Espere até que o status da aplicação esteja **Pronto** para começar a usar o Data Wrangler. Isso pode levar cerca de 5 minutos na primeira vez que você iniciar o Data Wrangler.
![\[Exemplo mostrando que o status do KernelGatewayaplicativo é Pronto na página Detalhes do usuário.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/gatewayKernel-ready.png)
1. Para começar, escolha uma fonte de dados e use-a para importar um conjunto de dados. Para saber mais, consulte [Importar](data-wrangler-import.md).
Quando você importa um conjunto de dados, ele aparece no seu fluxo de dados. Para saber mais, consulte [Crie e use um fluxo do Data Wrangler](data-wrangler-data-flow.md).
1. Após a importação de um conjunto de dados, o Data Wrangler infere automaticamente o tipo de dados em cada coluna. Escolha **\$1** ao lado da etapa **Tipos de dados** e selecione **Editar tipos de dados**.
**Importante**
Após adicionar transformações na etapa **Tipos de dados**, você não poderá atualizar em massa os tipos de coluna usando **Tipos de atualização**.
1. Use o fluxo de dados para adicionar transformações e análises. Para saber mais, consulte [Transformar dados](data-wrangler-transform.md) e [Analisar e visualizar](data-wrangler-analyses.md).
1. Para exportar um fluxo de dados completo, escolha **Exportar** e escolha uma opção de exportação. Para saber mais, consulte [Exportar](data-wrangler-data-export.md).
1. Por fim, escolha o ícone **Componentes e registros** e selecione **Data Wrangler** na lista suspensa para ver todos os arquivos .flow criados por você. Você pode usar esse menu para localizar e se mover entre fluxos de dados.
Depois de iniciar o Data Wrangler, você pode usar a seção a seguir para ver um passo a passo de como você pode usar o Data Wrangler para criar um fluxo de preparação de dados com ML.
## Atualizar o Data Wrangler
Recomendamos que você atualize periodicamente a aplicação Data Wrangler do Studio Classic para acessar os atributos e atualizações mais recentes. O nome do aplicativo Data Wrangler começa com. **sagemaker-data-wrang** Para saber como atualizar uma aplicação do Studio Classic, consulte [Encerre e atualize os aplicativos do Amazon SageMaker Studio Classic](studio-tasks-update-apps.md).
## Demonstração: Passo a passo do conjunto de dados Data Wrangler Titanic
As seções a seguir fornecem uma explicação passo a passo para ajudar você a começar a usar o Data Wrangler. Esse passo a passo pressupõe que você já tenha seguido as etapas em [Acesse o Data Wrangler](#data-wrangler-getting-started-access) e tenha aberto um novo arquivo de fluxo de dados que você pretende usar para a demonstração. Talvez você queira renomear esse arquivo .flow para algo semelhante como `titanic-demo.flow`.
Este passo a passo usa o [conjunto de dados do Titanic](https://s3.us-west-2.amazonaws.com/amazon-sagemaker-data-wrangler-documentation-artifacts/walkthrough_titanic.csv). É uma versão modificada do [conjunto de dados do Titanic](https://www.openml.org/d/40945) que você pode importar para o fluxo do Data Wrangler com mais facilidade. Esse conjunto de dados contém o status de sobrevivência, a idade, o gênero e a classe (que serve como um indicador da status econômico) dos passageiros a bordo da viagem inaugural do *RMS Titanic* em 1912.
Neste tutorial, você realizará as seguintes etapas:
1. Execute um destes procedimentos:
+ Abra seu fluxo do Data Wrangler e escolha **Usar conjunto de dados de amostra**.
+ Faça upload do [conjunto de dados do Titanic](https://s3.us-west-2.amazonaws.com/amazon-sagemaker-data-wrangler-documentation-artifacts/walkthrough_titanic.csv) no Amazon Simple Storage Service (Amazon S3) e, em seguida, importe esse conjunto de dados para o Data Wrangler.
1. Analise o conjunto de dados usando as análises do Data Wrangler.
1. Defina um fluxo de dados usando as transformações de dados do Data Wrangler.
1. Exporte seu fluxo para um caderno Jupyter que pode ser usado para criar um trabalho do Data Wrangler.
1. Processe seus dados e inicie um trabalho SageMaker de treinamento para treinar um classificador XGBoost binário.
### Faça upload do conjunto de dados no S3 e importe
Para começar, é possível usar um dos seguintes métodos para importar o conjunto de dados do Titanic para o Data Wrangler:
+ Importando o conjunto de dados diretamente do fluxo do Data Wrangler
+ Fazendo upload do conjunto de dados no Amazon S3 e depois importando para o Data Wrangler
Para importar o conjunto de dados diretamente para o Data Wrangler, abra o fluxo e escolha **Usar conjunto de dados de amostra**.
O upload do conjunto de dados no Amazon S3 e a importação para o Data Wrangler é mais próximo da experiência que você tem ao importar seus próprios dados. As informações a seguir explicam como fazer o upload do seu conjunto de dados e importá-lo.
Antes de começar a importar os dados para o Data Wrangler, baixe o [conjunto de dados do Titanic](https://s3.us-west-2.amazonaws.com/amazon-sagemaker-data-wrangler-documentation-artifacts/walkthrough_titanic.csv) e faça o upload em um bucket do Amazon S3 (Amazon S3) na região da AWS que você deseja concluir esta demonstração.
Se você for um novo usuário do Amazon S3, poderá fazer isso usando o recurso de arrastar e soltar no console do Amazon S3. Para saber como, consulte [Upload de arquivos e pastas usando arrastar e soltar](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/upload-objects.html#upload-objects-by-drag-and-drop) na Guia do usuário do Amazon Simple Storage Service.
**Importante**
Faça upload do seu conjunto de dados em um bucket do S3 na mesma AWS região que você deseja usar para concluir esta demonstração.
Quando seu conjunto de dados tiver sido carregado com êxito no Amazon S3, você poderá importá-lo para o Data Wrangler.
**Importe o conjunto de dados do Titanic para o Data Wrangler**
1. Escolha o botão **Importar dados** na guia **Fluxo de dados** ou escolha a guia **Importar**.
1. Selecione **Amazon S3**.
1. Use a tabela **Importar um conjunto de dados do S3** para encontrar o bucket onde você adicionou o conjunto de dados do Titanic. Escolha o arquivo CSV do conjunto de dados do Titanic para abrir o painel **Detalhes**.
1. Em **Detalhes**, o **tipo de arquivo** deve ser CSV. Marque **Primeira linha é cabeçalho** para especificar que a primeira linha do conjunto de dados é um cabeçalho. Você também pode nomear o conjunto de dados de forma mais conveniente, como **Titanic-train**.
1. Escolha o botão **Importar **.
Quando seu conjunto de dados é importado para o Data Wrangler, ele aparece na guia **Fluxo de dados**. Você pode clicar duas vezes em um nó para entrar na visualização de detalhes do nó, o que permite adicionar transformações ou análises. Você pode usar o ícone de adição para acesso rápido à navegação. Na próxima seção, você usará esse fluxo de dados para adicionar etapas de análise e transformação.
### Fluxo de dados
Na seção de fluxo de dados, as únicas etapas do fluxo de dados são seu conjunto de dados importado recentemente e uma etapa de **tipo de dados**. Depois de aplicar as transformações, você pode voltar a essa guia e ver como é o fluxo de dados. Agora, adicione algumas transformações básicas nas guias **Preparar** e **Analisar**.
#### Preparo e visualização
O Data Wrangler tem transformações e visualizações integradas que você pode usar para analisar, limpar e transformar seus dados.
A guia **Dados** da visualização de detalhes do nó lista todas as transformações integradas no painel direito, que também contém uma área onde você pode adicionar transformações personalizadas. O caso de uso a seguir mostra como usar essas transformações.
Para obter informações que possam ajudar você na exploração de dados e na engenharia de atributos, crie um relatório de qualidade dos dados e insights. As informações do relatório podem ajudar você a limpar e processar seus dados. Ele fornece informações como o número de valores ausentes e o número de valores atípicos. Caso tenha problemas com seus dados, como vazamento ou desequilíbrio de destino, o relatório de insights pode chamar sua atenção para esses problemas. Para obter mais informações sobre como criar um relatório, consulte [Obtenha insights sobre dados e qualidade dos dados](data-wrangler-data-insights.md).
##### Exploração de dados
Primeiro, crie um resumo da tabela dos dados usando uma análise. Faça o seguinte:
1. Escolha o **\$1** ao lado da etapa **Tipo de dados** em seu fluxo de dados e selecione **Adicionar análise**.
1. Na área **Análise**, selecione **Resumo da tabela** na lista suspensa.
1. Dê um **nome** ao resumo da tabela.
1. Selecione **Visualizar** para visualizar a tabela que será criada.
1. Escolha **Salvar** para salvar em seu fluxo de dados. Ela aparecerá em **Todas as análises**.
Usando as estatísticas que você vê, você pode fazer observações semelhantes às seguintes sobre esse conjunto de dados:
+ A média da tarifa (média) é de cerca de US\$1 33, enquanto a máxima é superior a US\$1 500. Essa coluna provavelmente tem valores atípicos.
+ Este conjunto de dados usa *?* para indicar valores ausentes. Várias colunas têm valores ausentes: *cabine*, *embarcou* e *destino.inicial*
+ A categoria de idade não tem mais de 250 valores.
Em seguida, limpe seus dados usando os insights obtidos com essas estatísticas.
##### Descarte de colunas não utilizadas
Usando a análise da seção anterior, limpe o conjunto de dados para prepará-lo para o treinamento. Para adicionar uma nova transformação ao seu fluxo de dados, escolha **\$1** ao lado da etapa **Tipo de dados** em seu fluxo de dados e escolha **Adicionar transformação**.
Primeiro, descarte as colunas que você não deseja utilizar para treinamento. Você pode usar a biblioteca de análise de dados do [pandas](https://pandas.pydata.org/) para fazer isso ou usar uma das transformações integradas.
Use o procedimento a seguir para descartar as colunas não utilizadas.
Para descartar as colunas não utilizadas.
1. Abra o fluxo do Data Wrangler.
1. Há dois nós no fluxo do Data Wrangler. Escolha o **\$1** à direita do nó **Tipos de dados**.
1. Escolha **Adicionar transformação**.
1. Na coluna **Todas as etapas**, escolha **Adicionar etapa**.
1. Na lista Transformação **padrão**, escolha **Gerenciar colunas**. As transformações padrão são transformações prontas e integradas. Lembre-se de verificar se a opção **Eliminar coluna** está selecionada.
1. Em **Colunas a serem eliminadas**, verifique os seguintes nomes de colunas:
+ cabine
+ bilhete
+ name
+ sibsp
+ parch
+ destino.inicial
+ barco
+ body
1. Escolha **Pré-visualizar**.
1. Verifique se as colunas foram eliminadas e escolha **Adicionar**.
Para fazer isso usando o pandas, siga estas etapas:
1. Na coluna **Todas as etapas**, escolha **Adicionar etapa**.
1. Na lista Transformação **personalizada**, escolha **Transformação personalizada**.
1. Forneça um nome para sua transformação e escolha **Python (Pandas)** na lista suspensa.
1. Insira o seguinte script Python na caixa de código:
```
cols = ['name', 'ticket', 'cabin', 'sibsp', 'parch', 'home.dest','boat', 'body']
df = df.drop(cols, axis=1)
```
1. Escolha **Visualizar** para visualizar a alteração e, em seguida, escolha **Adicionar** para adicionar a transformação.
##### Limpeza de valores ausentes
Agora, limpe os valores ausentes. Você pode fazer isso com o grupo de transformação **Lidar com valores ausentes**.
Várias colunas têm valores ausentes. Das colunas restantes, *idade* e *tarifa* contêm valores ausentes. Inspecione isso usando uma **Transformação personalizada**.
Usando a opção **Python (Pandas)**, use o seguinte para analisar rapidamente o número de entradas em cada coluna:
```
df.info()
```
![\[Exemplo: revise o número de entradas em cada coluna.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/inspect-missing-pandas.png)
Para eliminar linhas com valores ausentes na categoria *idade*, faça o seguinte:
1. Escolha **Processar ausentes**.
1. Escolha **Soltar ausentes** para o **Transformador**.
1. Escolha *idade* para a **coluna Entrada**.
1. Escolha **Visualizar** para ver o novo quadro de dados e, em seguida, escolha **Adicionar** para adicionar a transformação ao seu fluxo.
1. Repita o mesmo processo para a *tarifa*.
Você pode usar `df.info()` na seção **Transformação personalizada** para confirmar que todas as linhas agora têm 1.045 valores.
##### Pandas personalizados: codificar
Experimente a codificação plana usando o Pandas. A codificação de dados categóricos é o processo de criação de uma representação numérica para categorias. Por exemplo, se suas categorias são `Dog` e `Cat`, você pode codificar essas informações em dois vetores: `[1,0]` para representar `Dog`, e `[0,1]` para representar `Cat`.
1. Na seção **Transformação personalizada**, escolha **Python (Pandas)** na lista suspensa.
1. Insira o seguinte na caixa de código:
```
import pandas as pd
dummies = []
cols = ['pclass','sex','embarked']
for col in cols:
dummies.append(pd.get_dummies(df[col]))
encoded = pd.concat(dummies, axis=1)
df = pd.concat((df, encoded),axis=1)
```
1. Escolha **Visualizar** para visualizar a alteração. A versão codificada de cada coluna será adicionada ao conjunto de dados.
1. Escolha **Adicionar** para adicionar a transformação.
#### SQL personalizado: SELEÇÃO das colunas
Agora, selecione as colunas que você deseja manter usando SQL. Para esta demonstração, selecione as colunas listadas na instrução `SELECT` a seguir. Como *sobreviveu* é sua coluna-alvo para o treinamento, coloque essa coluna em primeiro lugar.
1. Na seção **Transformação personalizada**, selecione **SQL (PySpark SQL)** na lista suspensa.
1. Insira o seguinte na caixa de código:
```
SELECT survived, age, fare, 1, 2, 3, female, male, C, Q, S FROM df;
```
1. Escolha **Visualizar** para visualizar a alteração. As colunas listadas em sua instrução `SELECT` são as únicas colunas restantes.
1. Escolha **Adicionar** para adicionar a transformação.
### Exportação para um caderno do Data Wrangler
Ao terminar de criar um fluxo de dados, você tem várias opções de exportação. A seção a seguir explica como exportar para um caderno de trabalho do Data Wrangler. Um trabalho do Data Wrangler é usado para processar seus dados usando as etapas definidas em seu fluxo de dados. Para saber mais sobre todas as opções de exportação, consulte [Exportar](data-wrangler-data-export.md).
#### Exportação para um caderno de trabalho do Data Wrangler
Quando você exporta seu fluxo de dados usando um **trabalho do Data Wrangler**, o processo cria automaticamente um caderno Jupyter. Esse notebook abre automaticamente na sua instância do Studio Classic e está configurado para executar um trabalho de SageMaker processamento para executar o fluxo de dados do Data Wrangler, conhecido como trabalho do Data Wrangler.
1. Salve seu fluxo de dados. Selecione **Arquivo** e, em seguida, selecione **Salvar fluxo do Data Wrangler**.
1. Volte para a guia **Fluxo de dados**, selecione a última etapa em seu fluxo de dados (SQL) e escolha o **\$1** para abrir a navegação.
1. Escolha **Exportar** e **Amazon S3 (via caderno Jupyter)**. Isso abre um caderno Jupyter.
![\[Exemplo mostrando como abrir a navegação na guia de fluxo de dados no console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/export-select-step.png)
1. Escolha qualquer kernel do **Python 3 (Ciência de Dados)** para o **Kernel**.
1. Quando o kernel for iniciado, execute as células no caderno até **Kick off SageMaker Training Job (Opcional)**.
1. Opcionalmente, você pode executar as células no **Kick off SageMaker Training Job (Opcional)** se quiser criar um trabalho de treinamento de SageMaker IA para treinar um XGBoost classificador. Você pode encontrar o custo de executar um trabalho de SageMaker treinamento na [Amazon SageMaker Pricing](https://aws.amazon.com/sagemaker/pricing/).
Como alternativa, você pode adicionar os blocos de código encontrados no [XGBoost Classificador de treinamento](#data-wrangler-getting-started-train-xgboost) notebook e executá-los para usar a biblioteca de código [XGBoost](https://xgboost.readthedocs.io/en/latest/)aberto para treinar um XGBoost classificador.
1. Descomente e execute a célula em **Cleanup** e execute-a para reverter o SDK do SageMaker Python para sua versão original.
Você pode monitorar o status do trabalho do Data Wrangler no console de SageMaker IA na guia **Processamento**. Além disso, você pode monitorar seu trabalho no Data Wrangler usando a Amazon. CloudWatch Para obter informações adicionais, consulte [Monitorar trabalhos SageMaker de processamento da Amazon com CloudWatch registros e métricas](https://docs.aws.amazon.com/sagemaker/latest/dg/processing-job.html#processing-job-cloudwatch).
Se você iniciou um trabalho de treinamento, pode monitorar seu status usando o console de SageMaker IA em **Trabalhos de treinamento** na **seção Treinamento**.
#### XGBoost Classificador de treinamento
Você pode treinar um classificador XGBoost binário usando um notebook Jupyter ou um Amazon Autopilot. SageMaker Você pode usar o Autopilot para treinar e ajustar modelos automaticamente nos dados transformados diretamente em seu fluxo do Data Wrangler. Para obter informações sobre o Autopilot, consulte [Treine modelos automaticamente em seu fluxo de dados](data-wrangler-autopilot.md).
No mesmo notebook que deu início ao trabalho do Data Wrangler, você pode extrair os dados e treinar um classificador XGBoost binário usando os dados preparados com o mínimo de preparação de dados.
1. Primeiro, atualize os módulos necessários usando `pip` e remova o arquivo \$1SUCCESS (esse último arquivo é problemático durante o uso de `awswrangler`).
```
! pip install --upgrade awscli awswrangler boto sklearn
! aws s3 rm {output_path} --recursive --exclude "*" --include "*_SUCCESS*"
```
1. Leia os dados do Amazon S3. Você pode usar `awswrangler` para ler recursivamente todos os arquivos CSV no prefixo do S3. Os dados são então divididos em atributos e rótulos. O rótulo é a primeira coluna do quadro de dados.
```
import awswrangler as wr
df = wr.s3.read_csv(path=output_path, dataset=True)
X, y = df.iloc[:,:-1],df.iloc[:,-1]
```
+ Por fim, crie DMatrices (a estrutura XGBoost primitiva dos dados) e faça a validação cruzada usando a classificação XGBoost binária.
```
import xgboost as xgb
dmatrix = xgb.DMatrix(data=X, label=y)
params = {"objective":"binary:logistic",'learning_rate': 0.1, 'max_depth': 5, 'alpha': 10}
xgb.cv(
dtrain=dmatrix,
params=params,
nfold=3,
num_boost_round=50,
early_stopping_rounds=10,
metrics="rmse",
as_pandas=True,
seed=123)
```
#### Encerrando o Data Wrangler
Ao terminar de usar o Data Wrangler, recomendamos que você encerre a instância em que ele é executado para evitar cobranças adicionais. Para saber como encerrar a aplicação Data Wrangler e a instância associada, consulte [Encerrando o Data Wrangler](data-wrangler-shut-down.md).
# Importar
Você pode usar o Amazon SageMaker Data Wrangler para importar dados das seguintes *fontes* de dados: Amazon Simple Storage Service (Amazon S3), Amazon Athena, Amazon Redshift e Snowflake. O conjunto de dados que você importa pode incluir até 1.000 colunas.
**Topics**
+ [Importar dados do Amazon S3](#data-wrangler-import-s3)
+ [Importar dados do Athena](#data-wrangler-import-athena)
+ [Importar dados do Amazon Redshift](#data-wrangler-import-redshift)
+ [Importar dados do Amazon EMR](#data-wrangler-emr)
+ [Importar dados do Databricks (JDBC)](#data-wrangler-databricks)
+ [Importar dados do Salesforce Data Cloud](#data-wrangler-import-salesforce-data-cloud)
+ [Importar dados do Snowflake](#data-wrangler-snowflake)
+ [Importar dados de plataformas de software como serviço (SaaS)](#data-wrangler-import-saas)
+ [Armazenamento de dados importados](#data-wrangler-import-storage)
Algumas fontes de dados permitem que você adicione várias *conexões de dados*:
+ Você pode se conectar a vários clusters do Amazon Redshift. Cada cluster se torna uma fonte de dados.
+ Você pode consultar qualquer banco de dados do Athena em sua conta para importar dados desse banco de dados.
Quando você importa um conjunto de dados de uma fonte de dados, ele aparece no seu fluxo de dados. O Data Wrangler infere automaticamente o tipo de dados de cada coluna em seu conjunto de dados. Para modificar esses tipos, selecione a etapa **Tipos de dados** e selecione **Editar tipos de dados**.
Quando você importa dados do Athena ou do Amazon Redshift, os dados importados são armazenados automaticamente no bucket AI S3 SageMaker padrão para a região na qual você está AWS usando o Studio Classic. Além disso, o Athena armazena os dados que você visualiza no Data Wrangler neste bucket. Para saber mais, consulte [Armazenamento de dados importados](#data-wrangler-import-storage).
**Importante**
O bucket padrão do Amazon S3 pode não ter as configurações de segurança menos permissivas, como política de bucket e criptografia do lado do servidor (SSE). É altamente recomendável que você [Adicione uma política de bucket para restringir o acesso aos conjuntos de dados importados para o Data Wrangler](https://docs.aws.amazon.com/sagemaker/latest/dg/data-wrangler-security.html#data-wrangler-security-bucket-policy).
**Importante**
Além disso, se você usa a política gerenciada para SageMaker IA, é altamente recomendável que você a reduza até a política mais restritiva que permita realizar seu caso de uso. Para obter mais informações, consulte [Conceder permissão a um perfil do IAM para usar o Data Wrangler](data-wrangler-security.md#data-wrangler-security-iam-policy).
Todas as fontes de dados, exceto o Amazon Simple Storage Service (Amazon S3), exigem que você especifique uma consulta SQL para importar seus dados. Para cada consulta, você deve especificar o seguinte:
+ **Catálogo de dados**
+ **Banco de dados**
+ **Tabela**
Você pode especificar o nome do banco de dados ou do catálogo de dados nos menus suspensos ou na consulta. Veja os exemplos de consultas:
+ `select * from example-data-catalog-name.example-database-name.example-table-name` - A consulta não usa nada especificado nos menus suspensos da interface do usuário (UI) para ser executada. Ele consulta `example-table-name` dentro de `example-database-name` dentro de `example-data-catalog-name`.
+ `select * from example-database-name.example-table-name` - A consulta usa o catálogo de dados que você especificou no menu suspenso **Catálogo de dados** para ser executada. Ele consulta `example-table-name` dentro de `example-database-name` do catálogo de dados que você especificou.
+ `select * from example-table-name`: a consulta exige que você selecione campos para os menus suspensos **Catálogo de dados** e **Nome do banco de dados**. Faz consultas em `example-table-name` dentro do catálogo de dados dentro do banco de dados e catálogo de dados que você especificou.
O link entre o Data Wrangler e a fonte de dados é uma * conexão*. Você usa a conexão para importar dados da sua fonte de dados.
Existem os seguintes tipos de conexões:
+ Direta
+ Catalogado
O Data Wrangler sempre tem acesso aos dados mais recentes em uma conexão direta. Se os dados na fonte de dados foram atualizados, você pode usar a conexão para importar os dados. Por exemplo, se alguém adicionar um arquivo a um dos seus buckets do Amazon S3, você poderá importar o arquivo.
Uma conexão catalogada é o resultado de uma transferência de dados. Os dados na conexão catalogada não têm necessariamente os dados mais recentes. Por exemplo, você pode configurar uma transferência de dados entre o Salesforce e o Amazon S3. Se houver uma atualização nos dados do Salesforce, você deverá transferir os dados novamente. Você pode automatizar o processo de transferência de dados. Para obter mais informações sobre transferências de dados, consulte [Importar dados de plataformas de software como serviço (SaaS)](#data-wrangler-import-saas).
## Importar dados do Amazon S3
Você pode usar o Amazon Simple Storage Service (Amazon S3) para armazenar e recuperar qualquer volume de dados, a qualquer momento, de qualquer lugar na web. Você pode realizar essas tarefas usando a Console de gerenciamento da AWS, que é uma interface web simples e intuitiva, e a API do Amazon S3. Se você armazenou seu conjunto de dados localmente, recomendamos que você o adicione a um bucket do S3 para importação no Data Wrangler. Para aprender como fazer isso, consulte [Fazer upload de um objeto para um bucket](https://docs.aws.amazon.com/AmazonS3/latest/gsg/PuttingAnObjectInABucket.html) no Guia do Usuário do Amazon Simple Storage Service.
O Data Wrangler usa o [S3 Select](https://aws.amazon.com/s3/features/#s3-select) para permitir que você visualize seus arquivos Amazon S3 no Data Wrangler. Você incorre em cobranças padrão para cada visualização prévia do arquivo. Para saber mais sobre preços, consulte a guia **Solicitações e recuperação de dados** na definição de preço do [Amazon S3](https://aws.amazon.com/s3/pricing/).
**Importante**
Se você planeja exportar um fluxo de dados e iniciar um trabalho do Data Wrangler, ingerir dados em uma SageMaker loja de recursos de IA ou criar um pipeline de SageMaker IA, saiba que essas integrações exigem que os dados de entrada do Amazon S3 estejam localizados na mesma região. AWS
**Importante**
Se você estiver importando um arquivo CSV, verifique se ele cumpre os requisitos a seguir:
Um registro no seu conjunto de dados não pode ser maior que uma linha.
Uma barra invertida, `\`, é o único caractere de escape válido.
Seu conjunto de dados deve usar um dos seguintes delimitadores:
Vírgula - `,`
Dois pontos - `:`
Ponto e vírgula - `;`
Barra vertical - `|`
Aba - `[TAB]`
Para economizar espaço, você pode importar arquivos CSV compactados.
O Data Wrangler permite importar todo o conjunto de dados ou amostrar uma parte dele. Para o Amazon S3, ele fornece as seguintes opções de amostragem:
+ Nenhum: Importar todo o conjunto de dados.
+ Primeiro K: Fazer uma amostra das primeiras K linhas do conjunto de dados, em que K é um número inteiro que você especifica.
+ Aleatório - obtém uma amostra aleatória de um tamanho especificado por você.
+ Estratificado - obtém uma amostra aleatória estratificada. Uma amostra estratificada preserva proporção de valores em uma coluna.
Depois de importar seus dados, você também pode usar o transformador de amostragem para obter uma ou mais amostras de todo o seu conjunto de dados. Para obter mais informações sobre a transformação de amostra, consulte [Amostragem](data-wrangler-transform.md#data-wrangler-transform-sampling).
É possível usar um dos seguintes identificadores de recurso para importar seus dados:
+ Um URI do Amazon S3 que usa um bucket do Amazon S3 ou pontos de acesso Amazon S3
+ Um alias de ponto de acesso Amazon S3.
+ Um nome do recurso da Amazon (ARN) que usa um bucket do Amazon S3 ou pontos de acesso Amazon S3
Os pontos de Acesso Amazon S3 são endpoints de rede anexados a buckets. Cada ponto de acesso possui permissões distintas e controles de rede que você pode configurar. Para obter mais informações sobre pontos de acesso, consulte [Como gerenciar o acesso a dados com os pontos de acesso Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/access-points.html).
**Importante**
Se você estiver usando um Amazon Resource Name (ARN) para importar seus dados, ele deve ser para um recurso localizado no mesmo Região da AWS que você está usando para acessar o Amazon SageMaker Studio Classic.
Você pode importar um único arquivo ou vários arquivos como um conjunto de dados. É possível usar a operação de importação de vários arquivos quando você tem um conjunto de dados que é particionado em arquivos separados. Pega todos os arquivos de um diretório do Amazon S3 e os importa como um único conjunto de dados. Para obter informações sobre os tipos de arquivos que você pode importar e como importá-los, consulte as seções a seguir.
------
#### [ Single File Import ]
Você pode importar arquivos individuais nos seguintes formatos:
+ Valores separados por vírgula (CSV)
+ Parquet
+ Notação de objetos JavaScript (JSON)
+ Colunar otimizado para linhas (ORC)
+ Imagem - O Data Wrangler usa o OpenCV para importar imagens. Para obter mais informações sobre os formatos de imagem compatíveis, consulte [Leitura e gravação de arquivos de imagem](https://docs.opencv.org/3.4/d4/da8/group__imgcodecs.html#ga288b8b3da0892bd651fce07b3bbd3a56).
Para arquivos formatados em JSON, o Data Wrangler é compatível com linhas JSON (.jsonl) e documentos JSON (.json). Quando você visualiza seus dados, ele mostra automaticamente o JSON em formato tabular. Para documentos JSON aninhados com mais de 5 MB, o Data Wrangler mostra o esquema da estrutura e das matrizes como valores no conjunto de dados. Use os operadores **Nivelados estruturados** e **Explodir a matriz** para exibir os valores aninhados em formato tabular. Para obter mais informações, consulte [Desaninhar dados JSON](data-wrangler-transform.md#data-wrangler-transform-flatten-column) e [Explodir matriz](data-wrangler-transform.md#data-wrangler-transform-explode-array).
Ao escolher um conjunto de dados, você pode renomeá-lo, especificar o tipo de arquivo e identificar a primeira linha como cabeçalho.
Você pode importar um conjunto de dados que você particionou em vários arquivos em um bucket do Amazon S3 em uma única etapa de importação.
**Para importar um conjunto de dados para o Data Wrangler a partir de um único arquivo que você armazenou no Amazon S3:**
1. Se você não estiver atualmente na guia **Importar**, escolha **Importar**.
1. Em **Disponível**, escolha **Amazon S3**.
1. Em **Importar dados tabulares, dados de imagem ou dados de séries temporais do S3**, faça o seguinte:
+ Escolha um bucket do Amazon S3 na visualização tabular e navegue até o arquivo que você está importando.
+ Para a **fonte do S3**, especifique um bucket do Amazon S3 ou um URI do Amazon S3 e selecione **Go**. O Amazon S3 URIs pode estar em um dos seguintes formatos:
+ `s3://amzn-s3-demo-bucket/example-prefix/example-file`
+ *example-access-point*- -s3alias/conjuntos *aqfqprnstn7aefdfbarligizwgyfouse1a* de dados/ *example-file*
+ `s3://arn:aws:s3:AWS-Region:111122223333:accesspoint/example-prefix/example-file`
1. Escolha o conjunto de dados para abrir o painel **Importar configurações**.
1. Se o seu arquivo CSV tiver um cabeçalho, selecione a caixa de seleção ao lado de **Adicionar cabeçalho à tabela**.
1. Use a tabela de **Visualização** para visualizar seu conjunto de dados. Essa tabela mostra até 100 linhas.
1. No painel **Detalhes**, verifique ou altere o **nome** e o **tipo de arquivo** do seu conjunto de dados. Se você adicionar um **Nome** que contenha espaços, esses espaços serão substituídos por sublinhados quando seu conjunto de dados for importado.
1. Especifique a configuração de amostragem que gostaria de usar.
1. Escolha **Importar**.
------
#### [ Multifile Import ]
A seguir estão os requisitos para importar vários arquivos:
+ Os arquivos devem estar na mesma pasta do seu bucket do Amazon S3.
+ Os arquivos devem compartilhar o mesmo cabeçalho ou não ter cabeçalho.
Cada arquivo deve estar em um dos seguintes formatos:
+ CSV
+ Parquet
+ Colunar otimizado para linhas (ORC)
+ Imagem - O Data Wrangler usa o OpenCV para importar imagens. Para obter mais informações sobre os formatos de imagem compatíveis, consulte [Leitura e gravação de arquivos de imagem](https://docs.opencv.org/3.4/d4/da8/group__imgcodecs.html#ga288b8b3da0892bd651fce07b3bbd3a56).
Siga o procedimento abaixo para importar vários arquivos.
**Para importar um conjunto de dados para o Data Wrangler a partir de vários arquivos que você armazenou em um diretório do Amazon S3**
1. Se você não estiver atualmente na guia **Importar**, escolha **Importar**.
1. Em **Disponível**, escolha **Amazon S3**.
1. Em **Importar dados tabulares, dados de imagem ou dados de séries temporais do S3**, faça o seguinte:
+ Escolha um bucket do Amazon S3 na visualização tabular e navegue até a pasta que contém os arquivos que você está importando.
+ Para a **fonte do S3**, especifique um bucket do Amazon S3 ou um URI do Amazon S3 e selecione **Ir**. Os itens a seguir são válidos URIs:
+ `s3://amzn-s3-demo-bucket/example-prefix/example-prefix`
+ `example-access-point-aqfqprnstn7aefdfbarligizwgyfouse1a-s3alias/example-prefix/`
+ `s3://arn:aws:s3:AWS-Region:111122223333:accesspoint/example-prefix`
1. Selecione a pasta que contém os arquivos que você quer importar. Cada arquivo deve estar em um dos formatos compatíveis. Seus arquivos devem ser do mesmo tipo de dados.
1. Se sua pasta tiver arquivos CSV com cabeçalhos, marque a caixa de seleção ao lado da **Primeira linha é um cabeçalho**.
1. Se seus arquivos estiverem aninhados em outras pastas, marque a caixa de seleção ao lado de **Incluir diretórios aninhados**.
1. (Opcional) Escolha **Adicionar coluna de nome de arquivo** e adicione uma coluna ao conjunto de dados que mostre o nome do arquivo para cada observação.
1. (Opcional) Por padrão, o Data Wrangler não mostra uma prévia de uma pasta. Você pode ativar a visualização escolhendo o botão azul de **Desligar a visualização**. Uma prévia mostra as primeiras 10 linhas dos primeiros 10 arquivos na pasta.
1. No painel **Detalhes**, verifique ou altere o **nome** e o **tipo de arquivo** do seu conjunto de dados. Se você adicionar um **Nome** que contenha espaços, esses espaços serão substituídos por sublinhados quando seu conjunto de dados for importado.
1. Especifique a configuração de amostragem que gostaria de usar.
1. Escolha **Importar conjunto de dados.**
------
Você também pode usar parâmetros para importar um subconjunto de arquivos que correspondam a um padrão. Os parâmetros ajudam você a escolher de forma mais seletiva os arquivos que você está importando. Para começar a utilizar parâmetros, edite a fonte de dados e aplique-os ao caminho que você está utilizando para importar os dados. Para obter mais informações, consulte [Reutilização de fluxos de dados para diferentes conjuntos de dados](data-wrangler-parameterize.md).
## Importar dados do Athena
Use o Amazon Athena para importar dados do Amazon Simple Storage Service (Amazon S3) para o Data Wrangler. No Athena, você escreve consultas SQL padrão para selecionar os dados que você está importando do Amazon S3. Para obter mais informações, consulte [O que é o Amazon Athena?](https://docs.aws.amazon.com/athena/latest/ug/what-is.html)
Você pode usar o Console de gerenciamento da AWS para configurar o Amazon Athena. Você deve criar pelo menos um banco de dados no Athena antes de começar a executar consultas. Para obter mais informações sobre como começar com o Athena, consulte [Conceitos básicos](https://docs.aws.amazon.com/athena/latest/ug/getting-started.html).
O Athena está diretamente integrado ao Data Wrangler. Você pode escrever consultas no Athena sem precisar sair da interface do Data Wrangler.
Além de escrever consultas simples no Athena no Data Wrangler, você também pode usar:
+ Grupos de trabalho do Athena para gerenciamento de resultados de consultas. Para obter mais informações sobre grupos de trabalho, consulte [Como gerenciar os resultados da consulta](#data-wrangler-import-manage-results).
+ Configurações de duração para definir períodos de retenção de dados. Para obter mais informações sobre a retenção de dados, consulte [Definir os períodos de retenção de dados](#data-wrangler-import-athena-retention).
### Consulte Athena no Data Wrangler
**nota**
O Data Wrangler não oferece apoio a consultas federadas.
Se você usa AWS Lake Formation com o Athena, certifique-se de que suas permissões do IAM do Lake Formation não substituam as permissões do IAM para o banco de dados. `sagemaker_data_wrangler`
O Data Wrangler permite importar todo o conjunto de dados ou amostrar uma parte dele. Para o Athena, ele oferece as seguintes opções de amostragem:
+ Nenhum: Importar todo o conjunto de dados.
+ Primeiro K: Fazer uma amostra das primeiras K linhas do conjunto de dados, em que K é um número inteiro que você especifica.
+ Aleatório - obtém uma amostra aleatória de um tamanho especificado por você.
+ Estratificado - obtém uma amostra aleatória estratificada. Uma amostra estratificada preserva proporção de valores em uma coluna.
O procedimento a seguir mostra como importar um conjunto de dados do Athena para o Data Wrangler.
**Para importar um conjunto de dados do Athena para o Data Wrangler**
1. Faça login no [Amazon SageMaker AI Console](https://console.aws.amazon.com/sagemaker).
1. Escolha **Studio**.
1. Escolha **Iniciar aplicação**.
1. Na lista suspensa, selecione **Studio**.
1. Escolha o ícone Início.
1. Escolha **Dados**.
1. Escolha **Data Wrangler**.
1. Escolha **Importar dados**.
1. Em **Disponível**, escolha **Amazon Athena**.
1. Para **Catálogo de dados**, escolha um catálogo de dados.
1. Use a lista suspensa **Banco de dados** para selecionar o banco de dados que deseja consultar. Ao selecionar um banco de dados, você pode visualizar todas as tabelas em seu banco de dados usando as **Tabelas** listadas em **Detalhes**.
1. (Opcional) Escolha **Configuração avançada**.
1. Escolha um **Grupo de trabalho**.
1. Se seu grupo de trabalho não impôs o local de saída do Amazon S3 ou se você não usa um grupo de trabalho, especifique um valor para a **localização dos resultados da consulta no Amazon S3**.
1. (Opcional) Em **Período de retenção de dados**, marque a caixa de seleção para definir um período de retenção de dados e especificar o número de dias para armazenar os dados antes de serem excluídos.
1. (Opcional) Por padrão, o Data Wrangler salva a conexão. Você pode optar por desmarcar a caixa de seleção e não salvar a conexão.
1. Para **Amostragem**, escolha um método de amostragem. Escolha **Nenhum** para desativar a amostragem.
1. Digite sua consulta no editor de consultas e escolha **Executar** para executar a consulta. Após uma consulta bem-sucedida, você pode visualizar seu resultado abaixo do editor.
**nota**
Os dados do Salesforce usam o tipo `timestamptz`. Se você estiver consultando a coluna de timestamp que importou do Salesforce para o Athena, converta os dados na coluna para o tipo `timestamp`. A seguinte consulta converte a coluna de timestamp para o tipo correto:
```
# cast column timestamptz_col as timestamp type, and name it as timestamp_col
select cast(timestamptz_col as timestamp) as timestamp_col from table
```
1. Para importar os resultados da sua consulta, selecione **Importar**.
Depois de concluir o procedimento anterior, o conjunto de dados que você consultou e importou aparece no fluxo do Data Wrangler.
Por padrão, o Data Wrangler salva as configurações de conexão como uma nova conexão. Quando você importa seus dados, a consulta que você já especificou aparece como uma nova conexão. As conexões salvas armazenam informações sobre os grupos de trabalho do Athena e os buckets do Amazon S3 que você está usando. Ao se conectar novamente à fonte de dados, você pode escolher a conexão salva.
### Como gerenciar os resultados da consulta
O Data Wrangler oferece apoio ao uso de grupos de trabalho do Athena para gerenciar os resultados da consulta em uma conta AWS . Você pode especificar um local de saída do Amazon S3 para cada grupo de trabalho. Você também pode especificar se a saída da consulta pode ser direcionada para diferentes locais no Amazon S3. Para obter mais informações, consulte [Como usar os grupos de trabalho para controlar o acesso a consultas e custos](https://docs.aws.amazon.com/athena/latest/ug/manage-queries-control-costs-with-workgroups.html).
Seu grupo de trabalho pode estar configurado para impor o local de saída da consulta do Amazon S3. Você não pode alterar a localização de saída dos resultados da consulta para esses grupos de trabalho.
Se você não usa um grupo de trabalho nem especifica um local de saída para suas consultas, o Data Wrangler usa o bucket padrão do Amazon S3 na mesma AWS região em que sua instância do Studio Classic está localizada para armazenar os resultados da consulta do Athena. Ele cria tabelas temporárias neste banco de dados para transferir a saída da consulta para este bucket do Amazon S3. Ele exclui essas tabelas após a importação dos dados; no entanto, o banco de dados, `sagemaker_data_wrangler`, persiste. Para saber mais, consulte [Armazenamento de dados importados](#data-wrangler-import-storage).
Para usar grupos de trabalho no Athena, configure a política do IAM que concede acesso aos grupos de trabalho. Se você estiver usando um `SageMaker AI-Execution-Role`, recomendamos adicionar a política à função. Para obter mais informações sobre as políticas do IAM para grupos de trabalho, consulte [Políticas do IAM para acessar grupos de trabalho](https://docs.aws.amazon.com/athena/latest/ug/workgroups-iam-policy.html). Por exemplo, para políticas do grupo de trabalho, consulte [Políticas de exemplo do grupo de trabalho](https://docs.aws.amazon.com/athena/latest/ug/example-policies-workgroup.html).
### Definir os períodos de retenção de dados
O Data Wrangler define automaticamente um período de retenção de dados para os resultados da consulta. Os resultados são excluídos após o término do período de retenção. Por exemplo, o período de retenção padrão é de cinco dias. Os resultados da consulta são excluídos após cinco dias. Essa configuração é projetada para ajudar na limpeza de dados que você não está mais utilizando. Limpar seus dados impede que usuários não autorizados tenham acesso. Também ajuda a controlar os custos de armazenamento de seus dados no Amazon S3.
Se você não definir um período de retenção, a configuração do duração do Amazon S3 determinará a duração em que os objetos serão armazenados. A política de retenção de dados que você especificou para a configuração de duração remove quaisquer resultados de consulta que sejam mais antigos do que a configuração de duração que você especificou. Para obter mais informações, consulte [Definir configuração da duração de um bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/how-to-set-lifecycle-configuration-intro.html).
O Data Wrangler usa as configurações de duração do Amazon S3 para gerenciar a expiração e retenção de dados. Você deve conceder à sua função de execução do Amazon SageMaker Studio Classic IAM permissões para gerenciar as configurações do ciclo de vida do bucket. Use o seguinte procedimento para conceder permissões:
Para conceder permissões para gerenciar a configuração de duração, siga os seguintes passos:
1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Escolha **Perfis**.
1. Na barra de pesquisa, especifique a função de execução do Amazon SageMaker AI que o Amazon SageMaker Studio Classic está usando.
1. Escolha o perfil.
1. Escolha **Adicionar permissões**.
1. Escolha **Criar política em linha**.
1. Para **Serviço**, especifique **S3** e escolha-o.
1. Na seção **Ler**, escolha **GetLifecycleConfiguration**.
1. Na seção **Escrever**, escolha **PutLifecycleConfiguration**.
1. Em **Recursos**, selecione **Específico**.
1. Em **Ações**, selecione o ícone de seta ao lado de **Gerenciamento de permissões**.
1. Selecione **PutResourcePolicy**.
1. Em **Recursos**, selecione **Específico**.
1. Escolha a caixa de seleção ao lado de **Qualquer nesta conta**.
1. Selecione **Revisar política**.
1. Em **Nome**, especifique um nome.
1. Selecione **Criar política**.
## Importar dados do Amazon Redshift
O Amazon Redshift é um serviço de data warehouse totalmente gerenciado e em escala de petabytes na Nuvem . A primeira etapa para criar um data warehouse é executar um conjunto de nós, chamado cluster do Amazon Redshift. Depois de provisionar seu cluster, você pode fazer o upload do seu conjunto de dados e, em seguida, realizar consultas de análise de dados.
Você pode se conectar e consultar um ou mais clusters do Amazon Redshift no Data Wrangler. Para usar essa opção de importação, você deve criar pelo menos um cluster no Amazon Redshift. Para saber como, consulte [Conceitos básicos do Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/gsg/getting-started.html).
Você pode gerar os resultados da sua consulta do Amazon Redshift em um dos seguintes locais:
+ O bucket padrão do Amazon S3
+ Um local de saída do Amazon S3 que você especifica
Você pode importar o conjunto de dados inteiro ou fazer uma amostra de uma parte dele. Para o Amazon Redshift, ele fornece as seguintes opções de amostragem:
+ Nenhum: Importar todo o conjunto de dados.
+ Primeiro K: Fazer uma amostra das primeiras K linhas do conjunto de dados, em que K é um número inteiro que você especifica.
+ Aleatório - obtém uma amostra aleatória de um tamanho especificado por você.
+ Estratificado - obtém uma amostra aleatória estratificada. Uma amostra estratificada preserva proporção de valores em uma coluna.
O bucket padrão do Amazon S3 está na mesma AWS região em que sua instância do Studio Classic está localizada para armazenar os resultados da consulta do Amazon Redshift. Para obter mais informações, consulte [Armazenamento de dados importados](#data-wrangler-import-storage).
Para o bucket padrão do Amazon S3 ou para o bucket que você especificar, você tem as seguintes opções de criptografia:
+ A criptografia padrão do AWS lado do serviço com uma chave gerenciada do Amazon S3 (SSE-S3)
+ Uma chave AWS Key Management Service (AWS KMS) que você especifica
Uma AWS KMS chave é uma chave de criptografia que você cria e gerencia. Para obter mais informações sobre as chaves do KMS, consulte [AWS Key Management Service](https://docs.aws.amazon.com//kms/latest/developerguide/overview.html).
Você pode especificar uma AWS KMS chave usando o ARN da chave ou o ARN da sua conta. AWS
Se você usar a política gerenciada do IAM, `AmazonSageMakerFullAccess`, para conceder permissão à uma função para usar o Data Wrangler no Studio Classic, o nome de **usuário do banco de dados** deverá ter o prefixo `sagemaker_access`.
Utilize os procedimentos a seguir para aprender como adicionar um novo cluster.
**nota**
O Data Wrangler usa a API de dados do Amazon Redshift com credenciais temporárias. Para saber mais sobre essa API, consulte [Como usar a API de dados do Amazon Redshift](https://docs.aws.amazon.com//redshift/latest/mgmt/data-api.html) no Guia de gerenciamento do Amazon Redshift.
**Como se conectar a um cluster do Amazon Redshift**
1. Faça login no [Amazon SageMaker AI Console](https://console.aws.amazon.com/sagemaker).
1. Escolha **Studio**.
1. Escolha **Iniciar aplicação**.
1. Na lista suspensa, selecione **Studio**.
1. Escolha o ícone Início.
1. Escolha **Dados**.
1. Escolha **Data Wrangler**.
1. Escolha **Importar dados**.
1. Em **Disponível**, escolha **Amazon Athena**.
1. Escolha **Amazon Redshift**.
1. Escolha **Credenciais temporárias (IAM)** para **Tipo**.
1. Insira um **Nome de conexão**. Isso é um nome usado pelo Data Wrangler para identificar esta conexão.
1. Insira o **Identificador de cluster** para especificar a qual cluster você deseja se conectar. Observação: insira somente o identificador do cluster e não o endpoint completo do cluster do Amazon Redshift.
1. Insira o **Nome do banco de dados** ao qual deseja se conectar.
1. Insira um **Usuário do banco de dados** para identificar o usuário que você deseja usar para se conectar ao banco de dados.
1. Para a **DESCARREGAR perfil do IAM**, insira o ARN do perfil do IAM da função que o cluster do Amazon Redshift deve assumir para mover e gravar dados no Amazon S3. Para obter mais informações sobre essa função, consulte [Autorizar o Amazon Redshift a acessar AWS outros serviços em seu nome no Guia](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html) de gerenciamento do Amazon Redshift.
1. Selecione **Conectar**.
1. (Opcional) Para o **local de saída do Amazon S3**, especifique o URI do S3 para armazenar os resultados da consulta.
1. (Opcional) Para **ID da chave KMS**, especifique o ARN da chave ou AWS KMS alias. A imagem a seguir mostra onde você pode encontrar qualquer chave no Console de gerenciamento da AWS.
![\[A localização do ARN do AWS KMS alias, do nome do alias e do ARN da chave no console. AWS KMS\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/kms-alias-redacted.png)
A imagem a seguir mostra todos os campos do procedimento anterior.
![\[O painel Adicione uma conexão do Amazon Redshift.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/redshift-connection.png)
Depois que sua conexão for estabelecida com sucesso, ela aparecerá como uma fonte de dados em **Importação de dados**. Selecione essa fonte de dados para consultar seu banco de dados e importar dados.
**Para consultar e importar dados do Amazon Redshift:**
1. Selecione a conexão que você deseja consultar nas **Fontes de dados**.
1. Selecione um **Esquema**. Para saber mais sobre esquemas do Amazon Redshift, consulte [Esquemas](https://docs.aws.amazon.com/redshift/latest/dg/r_Schemas_and_tables.html) no Guia do desenvolvedor de banco de dados do Amazon Redshift.
1. (Opcional) Em **Configuração avançada**, especifique o método de **Amostragem** que você gostaria de usar.
1. Digite sua consulta no editor de consultas e escolha **Executar** para executar a consulta. Após uma consulta bem-sucedida, você pode visualizar seu resultado abaixo do editor.
1. Selecione **Importar conjunto de dados** para importar o conjunto de dados que foi consultado.
1. Insira um **nome de conjunto de dados**. Se você adicionar um **Nome de conjunto de dados** que contém espaços, esses espaços serão substituídos por underscores quando o conjunto de dados for importado.
1. Escolha **Adicionar**.
Para editar um conjunto de dados, siga os seguintes passos:
1. Navegue até o fluxo do Data Wrangler.
1. Escolha o \$1 ao lado de **Fonte - Amostragem**.
1. Alterar os dados que você está importando.
1. Escolha **Aplicar**
## Importar dados do Amazon EMR
Você pode usar o Amazon EMR como fonte de dados para seu fluxo do Amazon SageMaker Data Wrangler. O Amazon EMR é uma plataforma de cluster gerenciada que você pode usar para processar e analisar grandes quantidades de dados. Para obter mais informações sobre o Amazon EMR, consulte [O que é o Amazon EMR?](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-what-is-emr.html). Para importar um conjunto de dados do EMR, você se conecta a ele e o consulta.
**Importante**
É necessário cumprir os seguintes pré-requisitos para se conectar a um cluster do Amazon EMR:
Você tem uma Amazon VPC na região que está usando para iniciar o Amazon SageMaker Studio Classic e o Amazon EMR.
Tanto o Amazon EMR quanto o Amazon SageMaker Studio Classic devem ser lançados em sub-redes privadas. Podem estar na mesma sub-rede ou em sub-redes diferentes.
O Amazon SageMaker Studio Classic deve estar no modo somente VPC.
Para obter mais informações sobre como criar uma VPC, consulte [Criar uma VPC](https://docs.aws.amazon.com/vpc/latest/userguide/working-with-vpcs.html#Create-VPC).
Para obter mais informações sobre a criação de uma VPC, consulte [Connect SageMaker Studio Classic Notebooks em uma VPC](https://docs.aws.amazon.com/vpc/latest/userguide/studio-notebooks-and-internet-access.html) a recursos externos.
Os clusters do Amazon EMR que você está executando devem estar na mesma Amazon VPC.
Os clusters do Amazon EMR e o Amazon VPC devem estar na mesma conta. AWS
Seus clusters do Amazon EMR estão executando o Hive ou o Presto.
Os clusters do Hive devem permitir o tráfego de entrada dos grupos de segurança do Studio Classic na porta 10000.
Os clusters do Presto devem permitir tráfego de entrada dos grupos de segurança do Studio Classic na porta 8889.
O número da porta é diferente para clusters do Amazon EMR que usam funções do IAM. Navegue até o final da seção de pré-requisitos para obter mais informações.
O Amazon SageMaker Studio Classic deve executar o Jupyter Lab versão 3. Para obter informações sobre como atualizar a versão do Jupyter Lab, consulte [Visualize e atualize a JupyterLab versão de um aplicativo no console](studio-jl.md#studio-jl-view).
O Amazon SageMaker Studio Classic tem uma função do IAM que controla o acesso do usuário. A função padrão do IAM que você está usando para executar o Amazon SageMaker Studio Classic não tem políticas que possam lhe dar acesso aos clusters do Amazon EMR. É necessário anexar a política que concede permissões ao perfil do IAM. Para obter mais informações, consulte [Configurar a listagem de clusters do Amazon EMR](studio-notebooks-configure-discoverability-emr-cluster.md).
O perfil do IAM também deve ter a seguinte política anexada `secretsmanager:PutResourcePolicy`:
Se estiver utilizando um domínio do Studio Classic que já foi criado, certifique-se de que `AppNetworkAccessType` está no modo de somente VPC. Para obter informações sobre como atualizar um domínio para usar o modo somente VPC, consulte [Desligue e atualize o Amazon SageMaker Studio Classic](studio-tasks-update-studio.md).
Você deve ter o Hive ou o Presto instalados em seu cluster.
A versão do Amazon EMR deve ser da versão 5.5.0 ou posterior.
O Amazon EMR oferece apoio à terminação automática. A terminação automática impede a execução de clusters ociosos e evita que você incorra em custos. A seguir estão as versões que são compatíveis com a terminação automática:
Para versões 6.x, versão 6.1.0 ou posterior.
Para versões 5.x, versão 5.30.0 ou posterior.
Use as páginas a seguir para configurar perfis de runtime do IAM para o cluster do Amazon EMR. É necessário habilitar a criptografia em trânsito ao usar funções de runtime:
[Pré-requisitos para iniciar um cluster do Amazon EMR com um perfil de runtime](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-steps-runtime-roles.html#emr-steps-runtime-roles-configure)
[Iniciar um cluster do Amazon EMR com controle de acesso baseado em funções](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-steps-runtime-roles.html#emr-steps-runtime-roles-launch)
Você deve usar o Lake Formation como uma ferramenta de governança para os dados em seus bancos de dados. Você também deve usar a filtragem de dados externa para controle de acesso.
Para obter mais informações sobre Lake Formation, consulte [O que é AWS Lake Formation?](https://docs.aws.amazon.com/lake-formation/latest/dg/what-is-lake-formation.html)
Para obter mais informações sobre a integração do Lake Formation ao Amazon EMR, consulte [Integração de serviços de terceiros com o Lake Formation](https://docs.aws.amazon.com/lake-formation/latest/dg/Integrating-with-LakeFormation.html).
A versão do seu cluster deve ser 6.9.0 ou posterior.
Acesso AWS Secrets Manager a. Para obter mais informações sobre o Secrets Manager, consulte [O que é o AWS Secrets Manager?](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html)
Os clusters do Hive devem permitir o tráfego de entrada dos grupos de segurança do Studio Classic na porta 10000.
Uma Amazon VPC é uma rede virtual que está logicamente isolada de outras redes na nuvem. AWS O Amazon SageMaker Studio Classic e seu cluster do Amazon EMR só existem dentro da Amazon VPC.
Use o procedimento a seguir para iniciar o Amazon SageMaker Studio Classic em uma Amazon VPC.
Para executar o Studio Classic em uma VPC, siga os seguintes passos:
1. Navegue até o console de SageMaker IA em [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Escolha **Launch SageMaker Studio Classic**.
1. Escolha **Configuração padrão**.
1. Em **Perfil de execução padrão**, escolha o perfil do IAM para configurar o Studio Classic.
1. Escolha a VPC em que você lançou os clusters do Amazon EMR.
1. Em **Sub-rede**, escolha a sub-rede privada.
1. Para **Grupos de segurança**, especifique os grupos de segurança que você está usando para controlar entre sua VPC.
1. Escolha **Somente VPC**.
1. (Opcional) AWS usa uma chave de criptografia padrão. Você também pode especificar outra chave do AWS Key Management Service para criptografar os dados.
1. Escolha **Próximo**.
1. Em **Configurações do Studio**, selecione as configurações mais adequadas para suas necessidades.
1. Escolha **Avançar** para pular as configurações do SageMaker Canvas.
1. Escolha **Avançar** para ignorar as RStudio configurações.
Se você não tiver um cluster do Amazon EMR pronto, você pode seguir o procedimento abaixo para criar um. Para obter mais informações sobre o Amazon EMR, consulte [O que é o Amazon EMR?](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-what-is-emr.html).
Para criar um cluster, siga os seguintes passos:
1. Navegue até o Console de gerenciamento da AWS.
1. Na barra de pesquisa, especifique **Amazon EMR**.
1. Selecione **Criar cluster**.
1. Em **Nome do cluster**, especifique o nome do seu cluster.
1. Em **Lançar**, selecione a versão de lançamento do cluster.
**nota**
O Amazon EMR oferece apoio à terminação automática para as seguintes versões:
Para versões 6.x, versão 6.1.0 ou posterior.
Para versões 5.x, versão 5.30.0 ou posterior.
A terminação automática impede a execução de clusters ociosos e evita que você incorra em custos.
1. (Opcional) Para **Aplicativos**, escolha **Presto**.
1. Escolha a aplicação que você está executando no cluster.
1. Em **Redes**, para **Configuração de hardware**, especifique as configurações de hardware.
**Importante**
Em **Rede**, escolha a VPC que está executando o Amazon SageMaker Studio Classic e escolha uma sub-rede privada.
1. Em **Segurança e acesso**, especifique as configurações de segurança.
1. Escolha **Criar**.
Para ver um tutorial sobre a criação de um cluster do Amazon EMR, consulte [Conceitos básicos do Amazon EMR](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-gs.html). Para obter informações sobre as melhores práticas para configurar um cluster, consulte [Considerações e melhores práticas](https://docs.aws.amazon.com/emr/latest/ManagementGuide/emr-plan-ha-considerations.html).
**nota**
Para as melhores práticas de segurança, o Data Wrangler só pode se conectar VPCs em sub-redes privadas. Você não pode se conectar ao nó principal, a menos que use AWS Systems Manager para suas instâncias do Amazon EMR. Para obter mais informações, consulte [Protegendo o acesso aos clusters do EMR usando AWS Systems Manager](https://aws.amazon.com/blogs/big-data/securing-access-to-emr-clusters-using-aws-systems-manager/).
Atualmente, você pode usar os seguintes métodos para acessar um cluster do Amazon EMR:
+ Sem autenticação
+ Lightweight Directory Access Protocol (LDAP)
+ IAM (função de runtime)
Não usar a autenticação ou usar o LDAP pode exigir que você crie vários clusters e perfis de instância do Amazon EC2. Se você for um administrador, talvez seja necessário fornecer a grupos de usuários diferentes níveis de acesso aos dados. Esses métodos podem resultar em sobrecarga administrativa que dificulta o gerenciamento de seus usuários.
Recomendamos usar uma função de runtime do IAM que ofereça a vários usuários a capacidade de se conectar ao mesmo cluster do Amazon EMR. Uma função de runtime é um perfil do IAM que você pode atribuir a um usuário que está se conectando a um cluster do Amazon EMR. Você pode configurar o perfil do IAM em runtime para ter permissões específicas para cada grupo de usuários.
Use as seções a seguir para criar um cluster Presto ou Hive Amazon EMR com o LDAP ativado.
------
#### [ Presto ]
**Importante**
Para usar AWS Glue como metastore para tabelas do Presto, selecione **Usar** para **metadados da tabela Presto** para armazenar os resultados de suas consultas do Amazon EMR em um AWS Glue catálogo de dados ao iniciar um cluster do EMR. Armazenar os resultados da consulta em um catálogo de AWS Glue dados pode evitar que você incorra em cobranças.
Para consultar grandes conjuntos de dados em clusters do Amazon EMR, você deve adicionar as seguintes propriedades ao arquivo de configuração do Presto em seus clusters do Amazon EMR:
```
[{"classification":"presto-config","properties":{
"http-server.max-request-header-size":"5MB",
"http-server.max-response-header-size":"5MB"}}]
```
Também é possível modificar as definições de configuração ao executar o cluster do Amazon EMR.
O arquivo de configuração do seu cluster Amazon EMR está localizado no seguinte caminho: `/etc/presto/conf/config.properties`.
Use o procedimento a seguir para criar um cluster do Presto com o LDAP ativado.
Para criar um cluster, siga os seguintes passos:
1. Navegue até o Console de gerenciamento da AWS.
1. Na barra de pesquisa, especifique **Amazon EMR**.
1. Selecione **Criar cluster**.
1. Em **Nome do cluster**, especifique o nome do seu cluster.
1. Em **Lançar**, selecione a versão de lançamento do cluster.
**nota**
O Amazon EMR oferece apoio à terminação automática para as seguintes versões:
Para versões 6.x, versão 6.1.0 ou posterior.
Para versões 5.x, versão 5.30.0 ou posterior.
A terminação automático impede a execução de clusters ociosos e evita que você incorra em custos.
1. Escolha a aplicação que você está executando no cluster.
1. Em **Redes**, para **Configuração de hardware**, especifique as configurações de hardware.
**Importante**
Em **Rede**, escolha a VPC que está executando o Amazon SageMaker Studio Classic e escolha uma sub-rede privada.
1. Em **Segurança e acesso**, especifique as configurações de segurança.
1. Escolha **Criar**.
------
#### [ Hive ]
**Importante**
Para usar AWS Glue como metastore para tabelas do Hive, selecione **Usar** para **metadados da tabela do Hive** para armazenar os resultados de suas consultas do Amazon EMR em um AWS Glue catálogo de dados ao iniciar um cluster do EMR. Armazenar os resultados da consulta em um catálogo de AWS Glue dados pode evitar que você incorra em cobranças.
Para poder consultar grandes conjuntos de dados em clusters do Amazon EMR, adicione as seguintes propriedades ao arquivo de configuração do Hive em seus clusters do Amazon EMR:
```
[{"classification":"hive-site", "properties"
:{"hive.resultset.use.unique.column.names":"false"}}]
```
Também é possível modificar as definições de configuração ao executar o cluster do Amazon EMR.
O arquivo de configuração do seu cluster Amazon EMR está localizado no seguinte caminho: `/etc/hive/conf/hive-site.xml`. Você pode especificar a seguinte propriedade e reiniciar o cluster:
```
hive.resultset.use.unique.column.names
false
```
Use o procedimento a seguir para criar um cluster do Hive com o LDAP ativado.
Para criar um cluster do Hive com o LDAP ativado, siga os seguintes passos:
1. Navegue até o Console de gerenciamento da AWS.
1. Na barra de pesquisa, especifique **Amazon EMR**.
1. Selecione **Criar cluster**.
1. Escolha **Ir para opções avançadas**.
1. Para **Lançar**, selecione uma versão de lançamento do Amazon EMR.
1. A opção de configuração do **Hive** é selecionada por padrão. Certifique-se de que a opção **Hive** tenha uma caixa de seleção ao lado dela.
1. (Opcional) Você também pode selecionar o **Presto** como uma opção de configuração para ativar o Hive e o Presto em seu cluster.
1. (Opcional) Selecione **Usar para metadados da tabela Hive** para armazenar os resultados de suas consultas do Amazon EMR em um catálogo de dados. AWS Glue Armazenar os resultados da consulta em um AWS Glue catálogo pode evitar que você incorra em cobranças. Para obter mais informações, consulte [Usando o catálogo de AWS Glue dados como metastore para o](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-hive-metastore-glue.html) Hive.
**nota**
Armazenar os resultados da consulta em um catálogo de dados requer a versão 5.8.0 ou posterior do Amazon EMR.
1. Em **Inserir configuração**, especifique o seguinte JSON:
```
[
{
"classification": "hive-site",
"properties": {
"hive.server2.authentication.ldap.baseDN": "dc=example,dc=org",
"hive.server2.authentication": "LDAP",
"hive.server2.authentication.ldap.url": "ldap://ldap-server-dns-name:389"
}
}
]
```
**nota**
Como prática recomendada de segurança, recomendamos habilitar o SSL HiveServer adicionando algumas propriedades no JSON anterior do hive-site. Para obter mais informações, consulte [Habilitar SSL em HiveServer 2](https://docs.cloudera.com/HDPDocuments/HDP3/HDP-3.0.1/configuring-wire-encryption/content/enable_ssl_on_hiveserver2.html).
1. Especifique as configurações restantes do cluster e crie um cluster.
------
Use as seções a seguir para usar a autenticação LDAP para clusters do Amazon EMR que você já criou.
------
#### [ LDAP for Presto ]
Usar o LDAP em um cluster executando o Presto requer acesso ao coordenador do Presto por meio do HTTPS. Faça o seguinte para fornecer acesso:
+ Ative o acesso na porta 636
+ Ativar SSL para o coordenador do Presto
Use o seguinte modelo para configurar o Presto:
```
- Classification: presto-config
ConfigurationProperties:
http-server.authentication.type: 'PASSWORD'
http-server.https.enabled: 'true'
http-server.https.port: '8889'
http-server.http.port: '8899'
node-scheduler.include-coordinator: 'true'
http-server.https.keystore.path: '/path/to/keystore/path/for/presto'
http-server.https.keystore.key: 'keystore-key-password'
discovery.uri: 'http://master-node-dns-name:8899'
- Classification: presto-password-authenticator
ConfigurationProperties:
password-authenticator.name: 'ldap'
ldap.url: !Sub 'ldaps://ldap-server-dns-name:636'
ldap.user-bind-pattern: "uid=${USER},dc=example,dc=org"
internal-communication.authentication.ldap.user: "ldap-user-name"
internal-communication.authentication.ldap.password: "ldap-password"
```
Para obter informações sobre configuração do LDAP no Presto, consulte os seguintes recursos:
+ [Autenticação LDAP](https://prestodb.io/docs/current/security/ldap.html)
+ [Usar autenticação LDAP para o Presto no Amazon EMR](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-presto-ldap.html)
**nota**
Como prática recomendada de segurança, recomendamos habilitar o SSL para o Presto. Para obter mais informações, consulte [Comunicação interna segura](https://prestodb.io/docs/current/security/internal-communication.html).
------
#### [ LDAP for Hive ]
Para usar o LDAP for Hive em um cluster que você criou, use o seguinte procedimento: [Reconfigure um grupo de instâncias](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-configure-apps-running-cluster.html#emr-configure-apps-running-cluster-considerations) no console.
Você está especificando o nome do cluster ao qual está se conectando.
```
[
{
"classification": "hive-site",
"properties": {
"hive.server2.authentication.ldap.baseDN": "dc=example,dc=org",
"hive.server2.authentication": "LDAP",
"hive.server2.authentication.ldap.url": "ldap://ldap-server-dns-name:389"
}
}
]
```
------
Use o procedimento a seguir para importar dados de um cluster.
Para importar dados de um cluster, siga os seguintes passos:
1. Abra um fluxo do Data Wrangler.
1. Escolha **Criar conexão**.
1. Escolha **Amazon EMR**.
1. Execute um destes procedimentos:
+ (Opcional) Para **Secrets ARN**, especifique o Amazon Resource Number (ARN) do banco de dados dentro do cluster. Os segredos fornecem segurança adicional. Para obter mais informações sobre segredos, consulte [O que é AWS Secrets Manager?](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) Para obter informações sobre como criar um segredo para seu cluster, consulte [Criando um AWS Secrets Manager segredo para seu cluster](#data-wrangler-emr-secrets-manager).
**Importante**
Você deve especificar um segredo se estiver usando uma função de runtime do IAM para autenticação.
+ Na tabela suspensa, escolha um cluster.
1. Escolha **Próximo**.
1. Em **Selecionar um endpoint para *example-cluster-name* cluster**, escolha um mecanismo de consulta.
1. (Opcional) Selecione **Salvar conexão**.
1. Escolha **Avançar, selecione login** e escolha uma das seguintes regras:
+ Sem autenticação
+ LDAP
+ IAM
1. Em **Login no *example-cluster-name* cluster**, especifique o **nome de usuário** e a **senha** do cluster.
1. Selecione **Conectar**.
1. No editor de consultas, especifique uma consulta SQL.
1. Escolha **Executar**.
1. Escolha **Importar**.
### Criando um AWS Secrets Manager segredo para seu cluster
Se estiver usando uma função de runtime do IAM para acessar seu cluster Amazon EMR, você deve armazenar as credenciais que está usando para acessar o Amazon EMR como um segredo no Secrets Manager. Você armazena todas as credenciais que usa para acessar o cluster dentro do segredo.
Você deve armazenar as seguintes informações em segredo:
+ Endpoint JDBC: `jdbc:hive2://`
+ Nome do DNS: o nome DNS do seu cluster do Amazon EMR. É o endpoint do nó primário ou o nome do host.
+ Porta - `8446`
Você também pode armazenar as seguintes informações adicionais dentro do segredo:
+ Perfil do IAM: O perfil do IAM que você está usando para acessar o cluster. O Data Wrangler usa sua função de execução de SageMaker IA por padrão.
+ Caminho do armazenamento confiável: Por padrão, o Data Wrangler cria um caminho do armazenamento confiável para você. Também é possível usar seu próprio caminho de armazenamento de confiança. Para obter mais informações sobre caminhos de armazenamento confiável, consulte [Criptografia em trânsito em 2](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/hs2-encryption-intransit.html). HiveServer
+ Senha do Truststore: Por padrão, o Data Wrangler cria uma senha do Truststore para você. Também é possível usar seu próprio caminho de armazenamento de confiança. Para obter mais informações sobre caminhos de armazenamento confiável, consulte [Criptografia em trânsito em 2](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/hs2-encryption-intransit.html). HiveServer
Use o procedimento a seguir para armazenar as credenciais em um segredo do Secrets Manager.
Para armazenar suas credenciais como um segredo, siga os seguintes passos:
1. Navegue até o Console de gerenciamento da AWS.
1. Na barra de pesquisa, especifique Secrets Manager.
1. Selecione **AWS Secrets Manager**.
1. Selecione **Armazenar um novo segredo**.
1. Em **Tipo de segredo**, escolha **Outro tipo de segredo**.
1. Em **Pares de chave/valor**, selecione **Texto sem formatação.**
1. Para clusters que executam o Hive, você pode usar o modelo a seguir para autenticação do IAM.
```
{"jdbcURL": ""
"iam_auth": {"endpoint": "jdbc:hive2://", #required
"dns": "ip-xx-x-xxx-xxx.ec2.internal", #required
"port": "10000", #required
"cluster_id": "j-xxxxxxxxx", #required
"iam_role": "arn:aws:iam::xxxxxxxx:role/xxxxxxxxxxxx", #optional
"truststore_path": "/etc/alternatives/jre/lib/security/cacerts", #optional
"truststore_password": "changeit" #optional
}}
```
**nota**
Depois de importar seus dados, você aplica transformações a eles. Em seguida, você exporta os dados que transformou para um local específico. Se você estiver utilizando um caderno Jupyter para exportar seus dados transformados para o Amazon S3, é necessário usar o caminho do truststore especificado no exemplo anterior.
Um segredo do Secrets Manager armazena a URL do JDBC do cluster Amazon EMR como um segredo. Usar um segredo é mais seguro do que inserir diretamente suas credenciais.
Use o procedimento a seguir para armazenar o URL do JDBC como um segredo.
Para armazenar o URL do JDBC como um segredo, siga os seguintes passos:
1. Navegue até o Console de gerenciamento da AWS.
1. Na barra de pesquisa, especifique Secrets Manager.
1. Selecione **AWS Secrets Manager**.
1. Selecione **Armazenar um novo segredo**.
1. Em **Tipo de segredo**, escolha **Outro tipo de segredo**.
1. Para **pares de chave/valor**, especifique `jdbcURL` como chave e uma URL JDBC válida como valor.
O formato de um URL JDBC válido depende do uso da autenticação e do uso do Hive ou do Presto como mecanismo de consulta. A lista a seguir mostra os formatos de URL JBDC válidos para as diferentes configurações possíveis.
+ Hive, sem autenticação - `jdbc:hive2://emr-cluster-master-public-dns:10000/;`
+ Hive, autenticação LDAP: `jdbc:hive2://emr-cluster-master-public-dns-name:10000/;AuthMech=3;UID=david;PWD=welcome123;`
+ Para o Hive com SSL ativado, o formato de URL do JDBC depende se você usa um arquivo Java Keystore para a configuração do TLS. O Java Keystore File ajuda a verificar a identidade do nó principal do cluster Amazon EMR. Para usar um arquivo Java Keystore, gere-o em um cluster do EMR e carregue-o no Data Wrangler. Para gerar um arquivo, use o seguinte comando no cluster do Amazon EMR: `keytool -genkey -alias hive -keyalg RSA -keysize 1024 -keystore hive.jks`. Para obter informações sobre a execução de comandos em um cluster do Amazon EMR, consulte [Protegendo o acesso aos clusters do EMR](https://aws.amazon.com/blogs/big-data/securing-access-to-emr-clusters-using-aws-systems-manager/) usando. AWS Systems Manager Para carregar um arquivo, escolha a seta para cima na navegação à esquerda da interface do usuário do Data Wrangler.
A seguir estão os formatos de URL JDBC válidos para o Hive com SSL ativado:
+ Sem um arquivo Java Keystore: `jdbc:hive2://emr-cluster-master-public-dns:10000/;AuthMech=3;UID=user-name;PWD=password;SSL=1;AllowSelfSignedCerts=1;`
+ Com um arquivo Java Keystore: `jdbc:hive2://emr-cluster-master-public-dns:10000/;AuthMech=3;UID=user-name;PWD=password;SSL=1;SSLKeyStore=/home/sagemaker-user/data/Java-keystore-file-name;SSLKeyStorePwd=Java-keystore-file-passsword;`
+ Pronto, sem autenticação — jdbc:presto: //:8889/; *emr-cluster-master-public-dns*
+ Para o Presto com autenticação LDAP e SSL habilitado, o formato da URL JDBC depende se você está utilizando um arquivo Java Keystore para a configuração do TLS. O Java Keystore File ajuda a verificar a identidade do nó principal do cluster Amazon EMR. Para usar um arquivo Java Keystore, gere-o em um cluster do EMR e carregue-o no Data Wrangler. Para carregar um arquivo, escolha a seta para cima na navegação à esquerda da interface do usuário do Data Wrangler. Para obter informações sobre como criar um arquivo de armazenamento de chaves Java para o Presto, consulte Arquivo de [armazenamento de chaves Java](https://prestodb.io/docs/current/security/tls.html#server-java-keystore) para TLS. Para obter informações sobre a execução de comandos em um cluster do Amazon EMR, consulte [Protegendo o acesso aos clusters do EMR](https://aws.amazon.com/blogs/big-data/securing-access-to-emr-clusters-using-aws-systems-manager/) usando. AWS Systems Manager
+ Sem um arquivo Java Keystore: `jdbc:presto://emr-cluster-master-public-dns:8889/;SSL=1;AuthenticationType=LDAP Authentication;UID=user-name;PWD=password;AllowSelfSignedServerCert=1;AllowHostNameCNMismatch=1;`
+ Com um arquivo Java Keystore: `jdbc:presto://emr-cluster-master-public-dns:8889/;SSL=1;AuthenticationType=LDAP Authentication;SSLTrustStorePath=/home/sagemaker-user/data/Java-keystore-file-name;SSLTrustStorePwd=Java-keystore-file-passsword;UID=user-name;PWD=password;`
Durante o processo de importação de dados de um cluster do Amazon EMR, você pode ter problemas. Para obter informações sobre resolução de problemas, consulte [Solucionar problemas com o Amazon EMR](data-wrangler-trouble-shooting.md#data-wrangler-trouble-shooting-emr).
## Importar dados do Databricks (JDBC)
Você pode usar o Databricks como fonte de dados para seu fluxo do Amazon SageMaker Data Wrangler. Para importar um conjunto de dados do Databricks, utilize a funcionalidade de importação JDBC (Java Database Connectivity) para acessar o seu banco de dados Databricks. Depois de acessar o banco de dados, especifique uma consulta SQL para obter os dados e importá-los.
Presumimos que você tenha um cluster do Databricks em execução e que tenha configurado seu driver JDBC para ele. Para mais informações, consulte as seguintes páginas de documentação do Databricks:
+ [Driver JDBC](https://docs.databricks.com/integrations/bi/jdbc-odbc-bi.html#jdbc-driver)
+ [Parâmetros de configuração e conexão do JDBC](https://docs.databricks.com/integrations/bi/jdbc-odbc-bi.html#jdbc-configuration-and-connection-parameters)
+ [Parâmetros de autenticação](https://docs.databricks.com/integrations/bi/jdbc-odbc-bi.html#authentication-parameters)
O Data Wrangler armazena seu URL JDBC em. AWS Secrets Manager Você deve dar à sua função de execução do Amazon SageMaker Studio Classic IAM permissões para usar o Secrets Manager. Use o seguinte procedimento para conceder permissões:
Para conceder permissões ao Secrets Manager, siga os seguintes passos:
1. Faça login no Console de gerenciamento da AWS e abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Escolha **Perfis**.
1. Na barra de pesquisa, especifique a função de execução do Amazon SageMaker AI que o Amazon SageMaker Studio Classic está usando.
1. Escolha o perfil.
1. Escolha **Adicionar permissões**.
1. Escolha **Criar política em linha**.
1. Para **Serviço**, especifique **Secrets Manager** e escolha-o.
1. Em **Ações**, selecione o ícone de seta ao lado de **Gerenciamento de permissões**.
1. Selecione **PutResourcePolicy**.
1. Em **Recursos**, selecione **Específico**.
1. Escolha a caixa de seleção ao lado de **Qualquer nesta conta**.
1. Selecione **Revisar política**.
1. Em **Nome**, especifique um nome.
1. Selecione **Criar política**.
Você pode usar partições para importar seus dados mais rapidamente. As partições dão ao Data Wrangler a capacidade de processar os dados em paralelo. Por padrão, o Data Wrangler usa 2 partições. Para a maioria dos casos de uso, duas partições oferecem velocidades de processamento de dados quase ideais.
Se você optar por especificar mais de duas partições, também poderá especificar uma coluna para particionar os dados. O tipo dos valores na coluna deve ser numérico ou de data.
Recomendamos usar partições somente se você entender a estrutura dos dados e como eles são processados.
Você pode importar o conjunto de dados inteiro ou fazer uma amostra de uma parte dele. Para um banco de dados Databricks, ele fornece as seguintes opções de amostragem:
+ Nenhum: Importar todo o conjunto de dados.
+ Primeiro K: Fazer uma amostra das primeiras K linhas do conjunto de dados, em que K é um número inteiro que você especifica.
+ Aleatório - obtém uma amostra aleatória de um tamanho especificado por você.
+ Estratificado - obtém uma amostra aleatória estratificada. Uma amostra estratificada preserva proporção de valores em uma coluna.
Use o procedimento a seguir para importar seus dados de um banco de dados do Databricks.
Para importar dados do Databricks, siga os seguintes passos:
1. Faça login no [Amazon SageMaker AI Console](https://console.aws.amazon.com/sagemaker).
1. Escolha **Studio**.
1. Escolha **Iniciar aplicação**.
1. Na lista suspensa, selecione **Studio**.
1. Na guia **Importar dados** do seu fluxo do Data Wrangler, escolha **Databricks**.
1. Especifique os seguintes campos:
+ **Nome do conjunto de dados**: Um nome que você deseja usar para o conjunto de dados em seu fluxo do Data Wrangler.
+ **Driver**: **com.simba.spark.jdbc.Driver**.
+ **URL do JDBC**: O URL do banco de dados Databricks. A formatação do URL pode variar entre as instâncias do Databricks. Para obter informações sobre como encontrar a URL e especificar os parâmetros dentro dela, consulte Parâmetros de [configuração e conexão do JDBC](https://docs.databricks.com/integrations/bi/jdbc-odbc-bi.html#jdbc-configuration-and-connection-parameters). Veja a seguir um exemplo de como um URL pode ser formatado: jdbc:spark://aws-sagemaker-datawrangler.cloud.databricks.com:443/default; transportMode=http; ssl=1; httpPath= /3122619508517275/0909-200301-cut318; =3; UID=; PWD=. sql/protocolv1/o AuthMech *token* *personal-access-token*
**nota**
Você pode especificar um ARN secreto que contenha a URL do JDBC em vez de especificar a própria URL do JDBC. O segredo deve conter um par de valores-chave com o seguinte formato: `jdbcURL:JDBC-URL`. Para obter mais informações, consulte [O que é o Secrets Manager?](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html)
1. Especifique uma instrução SQL SELECT.
**nota**
O Data Wrangler não oferece apoio a expressões de tabela comuns (CTE) ou tabelas temporárias em uma consulta.
1. Para **Amostragem**, escolha um método de amostragem.
1. Escolha **Executar**.
1. (Opcional) Para o **VISUALIZAÇÃO**, escolha a engrenagem para abrir as **configurações de partição**.
1. Especifique o número de partições. Você pode particionar por coluna se especificar o número de partições:
+ **Insira o número de partições**: Especifique um valor maior que 2.
+ (Opcional) **Partição por coluna**: Especifique os seguintes campos: Você só pode particionar por uma coluna se tiver especificado um valor para **Inserir número de partições**.
+ **Selecionar coluna**: Selecione a coluna que você está usando para a partição de dados. O tipo de dados da coluna deve ser numérico ou de data.
+ **Limite superior**: Dos valores na coluna que você especificou, o limite superior é o valor que você está usando na partição. O valor que você especifica não altera os dados que você está importando. Isso afeta apenas a velocidade da importação. Para obter o melhor desempenho, especifique um limite superior próximo do máximo da coluna.
+ **Limite inferior**: Dos valores na coluna que você especificou, o limite inferior é o valor que você está usando na partição. O valor que você especifica não altera os dados que você está importando. Isso afeta apenas a velocidade da importação. Para obter o melhor desempenho, especifique um limite inferior próximo ao mínimo da coluna.
1. Escolha **Importar**.
## Importar dados do Salesforce Data Cloud
Você pode usar o Salesforce Data Cloud como fonte de dados no Amazon Data Wrangler para preparar SageMaker os dados em seu Salesforce Data Cloud para aprendizado de máquina.
Com o Salesforce Data Cloud como fonte de dados no Data Wrangler, você pode conectar-se rapidamente aos dados do Salesforce sem escrever uma única linha de código. Você pode unir seus dados do Salesforce com dados de qualquer outra fonte de dados no Data Wrangler.
Depois de se conectar à nuvem de dados, você pode fazer o seguinte:
+ Visualize seus dados com visualizações integradas
+ Entenda os dados e identifique possíveis erros e valores extremos
+ Dados da transformação com mais de 300 transformações integradas
+ Exporte os dados que você transformou
**Topics**
+ [Configuração do administrador](#data-wrangler-import-salesforce-data-cloud-administrator)
+ [Guia do cientista de dados](#data-wrangler-salesforce-data-cloud-ds)
### Configuração do administrador
**Importante**
Antes de começar, certifique-se de que seus usuários estejam executando a versão 1.3.0 ou posterior do Amazon SageMaker Studio Classic. Para obter informações sobre como verificar a versão do Studio Classic e atualizá-la, consulte [Prepare dados de ML com o Amazon SageMaker Data Wrangler](data-wrangler.md).
Ao configurar o acesso ao Salesforce Data Cloud, você deve concluir as seguintes tarefas:
+ Obter seu URL de domínio do Salesforce. O Salesforce também se refere ao URL do domínio como o URL da sua organização.
+ Obter OAuth credenciais da Salesforce.
+ Obter o URL de autorização e o URL do token para seu domínio do Salesforce.
+ Criando um AWS Secrets Manager segredo com a OAuth configuração.
+ Criar uma configuração de duração que o Data Wrangler usa para ler as credenciais do segredo.
+ Conceder ao Data Wrangler permissões para ler o segredo.
Depois de realizar as tarefas anteriores, seus usuários podem fazer login no Salesforce Data Cloud usando. OAuth
**nota**
Seus usuários podem ter problemas depois de configurar tudo. Para obter informações sobre resolução de problemas, consulte [Solução de problemas com o Salesforce](data-wrangler-trouble-shooting.md#data-wrangler-troubleshooting-salesforce-data-cloud).
Siga o procedimento abaixo para obter o URL do domínio.
1. Navegue até a página de login [do Salesforce](login.salesforce.com).
1. Em **Busca rápida**, especifique **Meu domínio**.
1. Copie o valor da **URL atual do meu domínio** em um arquivo de texto.
1. Adicione `https://` ao início do URL.
Depois de obter o URL do domínio do Salesforce, você pode usar o procedimento a seguir para obter as credenciais de login do Salesforce e permitir que o Data Wrangler acesse seus dados do Salesforce.
Para obter as credenciais de login do Salesforce e fornecer acesso ao Data Wrangler, siga os seguintes passos:
1. Navegue até o URL do seu domínio do Salesforce e faça login na sua conta.
1. Escolha o ícone de engrenagem.
1. Na barra de pesquisa exibida, especifique **Gerenciador de aplicação**.
1. Selecione **Nova aplicação conectado**.
1. Especifique os seguintes campos:
+ Nome da aplicação conectado: Você pode especificar qualquer nome, mas recomendamos escolher um nome que inclua Data Wrangler. Por exemplo, você pode especificar a integração **do Salesforce Data Cloud Data Wrangler**.
+ Nome da API: use o valor padrão.
+ E-mail de contato: Especifique seu endereço de e-mail.
+ No **título API (Ativar OAuth configurações)**, marque a caixa de seleção para ativar OAuth as configurações.
+ Para URL de **retorno de chamada, especifique a URL** do Amazon SageMaker Studio Classic. Para obter a URL do Studio Classic, acesse-a a partir do Console de gerenciamento da AWS e copie a URL.
1. Em ** OAuth Escopos selecionados**, mova o seguinte dos Escopos **disponíveis para OAuth Escopos** **selecionados OAuth**:
+ Gerenciar dados do usuário via APIs (`api`)
+ Execute solicitações a qualquer momento (`refresh_token`, `offline_access`)
+ Execute consultas ANSI SQL em dados do Salesforce Data Cloud (`cdp_query_api`)
+ Gerenciar dados de perfil da Salesforce Customer Data Platform (`cdp_profile_api`)
1. Escolha **Salvar**. Depois de salvar suas alterações, o Salesforce abre uma nova página.
1. Escolha **Continue**
1. Navegue até **Chave e segredo do consumidor**.
1. Escolha **Gerenciar detalhes do consumidor**. O Salesforce redireciona você para uma nova página na qual talvez você precise passar pela autenticação de dois fatores.
1.
**Importante**
Copie a chave do consumidor e o segredo do consumidor em um editor de texto. Você precisa dessas informações para conectar a nuvem de dados ao Data Wrangler.
1. Navegue de volta para **Gerenciar aplicações conectados**.
1. Navegue até **Nome da aplicação conectado** e o nome da sua aplicação.
1. Escolha **Gerenciar**.
1. Selecione **Editar políticas**.
1. Altere o **Relaxamento de IP** para **relaxar as restrições de IP**.
1. Escolha **Salvar**.
Depois de fornecer acesso à sua Salesforce Data Cloud, você precisa fornecer permissões para seus usuários. Siga o procedimento abaixo para fornecer permissões.
Para fornecer permissões aos seus usuários, siga os seguintes passos:
1. Navegue até a página inicial de configuração.
1. Na navegação à esquerda, pesquise **Usuários** e escolha o item de menu **Usuários**.
1. Escolha o hiperlink com seu nome de usuário.
1. Navegue até **Atribuições do conjunto de permissões**.
1. Escolha **Editar exercícios.**
1. Adicione as seguintes permissões:
+ **Administrador da plataforma de dados do cliente**
+ **Especialista em reconhecimento de dados da plataforma de dados do cliente**
1. Escolha **Salvar**.
Depois de obter as informações do seu domínio do Salesforce, você deve obter a URL de autorização e a URL do token para o AWS Secrets Manager segredo que está criando.
Use o procedimento a seguir para obter o URL de autorização e o URL do token.
**Para obter o URL de autorização e o URL do token**
1. Navegue até o URL do seu domínio do Salesforce.
1. Use um dos métodos a seguir para obter URLs o. Se você estiver em uma distribuição Linux com `curl` e `jq` instalada, recomendamos usar o método que só funciona no Linux.
+ (Somente Linux) Especifique o seguinte comando em seu terminal:
```
curl salesforce-domain-URL/.well-known/openid-configuration | \
jq '. | { authorization_url: .authorization_endpoint, token_url: .token_endpoint }' | \
jq '. += { identity_provider: "SALESFORCE", client_id: "example-client-id", client_secret: "example-client-secret" }'
```
+
1. Navegue até **example-org-URL*/.well-known/openid-configuration* no navegador.
1. Copie o `authorization_endpoint` e `token_endpoint` para um editor de texto.
1. Crie o seguinte objeto JSON:
```
{
"identity_provider": "SALESFORCE",
"authorization_url": "example-authorization-endpoint",
"token_url": "example-token-endpoint",
"client_id": "example-consumer-key",
"client_secret": "example-consumer-secret"
}
```
Depois de criar o objeto OAuth de configuração, você pode criar um AWS Secrets Manager segredo que o armazene. Use o procedimento a seguir para criar o segredo.
Para criar um segredo, siga os seguintes passos:
1. Navegue até o [console do AWS Secrets Manager](https://console.aws.amazon.com/secretsmanager/).
1. Selecione **Armazenar um segredo**.
1. Selecione **Outro tipo de segredo**.
1. Em **Pares de chave/valor**, selecione **Texto sem formatação**.
1. Substitua o JSON vazio pelas seguintes configurações:
```
{
"identity_provider": "SALESFORCE",
"authorization_url": "example-authorization-endpoint",
"token_url": "example-token-endpoint",
"client_id": "example-consumer-key",
"client_secret": "example-consumer-secret"
}
```
1. Escolha **Próximo**.
1. Em **Nome secreto**, especifique o nome do segredo.
1. Em **Abas**, escolha **Adicionar**.
1. Para a **Chave**, especifique **sagemaker:partner**. Para **Valor**, recomendamos especificar um valor que possa ser útil para seu caso de uso. Porém, você não pode especificar qualquer coisa.
**Importante**
Você deve criar a chave. Você não pode importar seus dados do Salesforce se não os criar.
1. Escolha **Próximo**.
1. Escolha **Armazenar**.
1. Escolha o segredo que você criou.
1. Anote sobre os seguintes campos:
+ O Amazon Resource Number (ARN) do segredo.
+ O nome do segredo
Depois de criar o segredo, você deverá adicionar permissões para que o Data Wrangler leia o segredo. Use o seguinte procedimento para adicionar permissões:
Para adicionar permissões de leitura ao Data Wrangler, siga os seguintes passos:
1. Navegue até o [console Amazon SageMaker AI](https://console.aws.amazon.com/sagemaker/).
1. Escolha **Domínios**.
1. Escolha o domínio que você está usando para acessar o Data Wrangler.
1. Escolha seu **Perfil de usuário**.
1. Em **Detalhes**, encontre a **Função de execução**. O ARN está no seguinte formato: `arn:aws:iam::111122223333:role/example-role`. Anote a função de execução da SageMaker IA. Dentro do ARN, é tudo o que vem depois do `role/`.
1. Navegue até o [console do IAM](https://console.aws.amazon.com/iam).
1. Na barra de **pesquisa do Search IAM**, especifique o nome da função de execução da SageMaker IA.
1. Escolha o perfil.
1. Escolha **Adicionar permissões**.
1. Escolha **Criar política em linha**.
1. Selecione a guia JSON.
1. Especifique a política a seguir no editor.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"secretsmanager:GetSecretValue",
"secretsmanager:PutSecretValue"
],
"Resource": "arn:aws:secretsmanager:*:*:secret:*",
"Condition": {
"ForAnyValue:StringLike": {
"aws:ResourceTag/sagemaker:partner": "*"
}
}
},
{
"Effect": "Allow",
"Action": [
"secretsmanager:UpdateSecret"
],
"Resource": "arn:aws:secretsmanager:*:*:secret:AmazonSageMaker-*"
}
]
}
```
------
1. Escolha **Revisar política**.
1. Em **Nome**, especifique um nome.
1. Selecione **Criar política**.
Depois de conceder permissões ao Data Wrangler para ler o segredo, você deve adicionar uma configuração de ciclo de vida que usa seu segredo do Secrets Manager ao seu perfil de usuário do Amazon SageMaker Studio Classic.
Use o seguinte procedimento para criar uma configuração de ciclo de vida e adicioná-la ao perfil do Studio Classic:
Para criar uma configuração de clico de vida e adicioná-la ao perfil do Studio Classic, faça o seguinte:
1. Navegue até o [console Amazon SageMaker AI](console.aws.amazon.com/sagemaker).
1. Escolha **Domínios**.
1. Escolha o domínio que você está usando para acessar o Data Wrangler.
1. Escolha seu **Perfil de usuário**.
1. Se você ver os seguintes aplicações, exclua-os:
+ KernelGateway
+ JupyterKernel
**nota**
A exclusão das aplicações atualiza o Studio Classic. Pode demorar um pouco para que as atualizações aconteçam.
1. Enquanto você espera que as atualizações aconteçam, escolha as **configurações do duração**.
1. Verifique se a página em que você está diz **Configurações de ciclo de vida do Studio**.
1. Escolha **Criar configuração**.
1. Certifique-se de que a aplicação** do servidor Jupyter** tenha sido selecionado.
1. Escolha **Próximo**.
1. Em **Nome**, especifique um nome para a configuração.
1. Para **Scripts**, especifique o seguinte script:
```
#!/bin/bash
set -eux
cat > ~/.sfgenie_identity_provider_oauth_config <
Use o seguinte para conectar o Salesforce Data Cloud e acessar seus dados no Data Wrangler:
**Importante**
Seu administrador precisa usar as informações nas seções anteriores para configurar o Salesforce Data Cloud. Se você estiver enfrentando problemas, entre em contato com eles para obter ajuda na solução de problemas.
Para abrir o Studio Classic e verificar sua versão, consulte o procedimento a seguir.
1. Use as etapas [Pré-requisitos](data-wrangler-getting-started.md#data-wrangler-getting-started-prerequisite) para acessar o Data Wrangler por meio do Amazon SageMaker Studio Classic.
1. Ao lado do usuário que você deseja usar para executar o Studio Classic, selecione **Executar aplicação**.
1. Escolha **Studio**.
**Para criar um conjunto de dados no Data Wrangler com dados do Salesforce Data Cloud**
1. Faça login no [Amazon SageMaker AI Console](https://console.aws.amazon.com/sagemaker).
1. Escolha **Studio**.
1. Escolha **Iniciar aplicação**.
1. Na lista suspensa, selecione **Studio**.
1. Escolha o ícone Início.
1. Escolha **Dados**.
1. Escolha **Data Wrangler**.
1. Escolha **Importar dados**.
1. Em **Disponível**, escolha **Salesforce Data Cloud**.
1. Em **Nome da conexão**, especifique um nome para sua conexão com o Salesforce Data Cloud.
1. Para **URL da organização**, especifique a URL da organização em sua conta do Salesforce. Você pode obter o URL dos seus administradores.
1. Selecione **Conectar**.
1. Especifique suas credenciais para fazer login no Salesforce.
Você pode começar a criar um conjunto de dados usando dados do Salesforce Data Cloud depois de se conectar a ele.
Depois de selecionar uma tabela, você pode escrever consultas e executá-las. A saída da sua consulta é exibida em **Resultados da consulta**.
Depois de definir a saída da sua consulta, você poderá importar a saída da sua consulta para um fluxo do Data Wrangler para realizar transformações de dados.
Depois de criar um conjunto de dados, navegue até a tela de **Fluxo de dados** para começar a transformar seus dados.
## Importar dados do Snowflake
Você pode usar o Snowflake como fonte de dados no Data Wrangler para preparar SageMaker dados no Snowflake para aprendizado de máquina.
Com o Snowflake como fonte de dados no Data Wrangler, você pode conectar-se rapidamente ao Snowflake sem escrever uma única linha de código. Você pode unir seus dados no Snowflake com dados de qualquer outra fonte de dados no Data Wrangler.
Uma vez conectado, você pode consultar interativamente os dados armazenados no Snowflake, transformar dados com mais de 300 transformações de dados pré-configuradas, entender os dados e identificar possíveis erros e valores extremos com um conjunto de modelos de visualização pré-configurados robustos, identificar rapidamente inconsistências em seu fluxo de trabalho de preparação de dados e diagnosticar problemas antes que os modelos sejam implantados na produção. Por fim, você pode exportar seu fluxo de trabalho de preparação de dados para o Amazon S3 para uso com outros recursos de SageMaker IA, como Amazon SageMaker Autopilot, Amazon SageMaker Feature Store e Amazon Pipelines. SageMaker
Você pode criptografar a saída de suas consultas usando uma AWS Key Management Service chave que você criou. Para obter mais informações sobre AWS KMS, consulte [AWS Key Management Service](https://docs.aws.amazon.com//kms/latest/developerguide/overview.html).
**Topics**
+ [Guia do administrador](#data-wrangler-snowflake-admin)
+ [Guia do cientista de dados](#data-wrangler-snowflake-ds)
### Guia do administrador
**Importante**
Para saber mais sobre controle de acesso granular e melhores práticas, consulte [Controle de acesso de segurança](https://docs.snowflake.com/en/user-guide/security-access-control.html).
Esta seção é para administradores do Snowflake que estão configurando o acesso ao Snowflake a partir do Data Wrangler. SageMaker
**Importante**
Você é responsável por gerenciar e monitorar o controle de acesso no Snowflake. O Data Wrangler não adiciona uma camada de controle de acesso em relação ao Snowflake.
O controle de acesso inclui o seguinte:
Os dados que um usuário acessa
(Opcional) A integração de armazenamento que fornece ao Snowflake a capacidade de gravar resultados de consulta em um bucket do Amazon S3
As consultas que um usuário pode executar
#### (Opcional) Configurar as permissões de importação de dados do Snowflake
Por padrão, o Data Wrangler consulta os dados no Snowflake sem criar uma cópia deles em um local do Amazon S3. Use as informações a seguir se estiver configurando uma integração de armazenamento com o Snowflake. Seus usuários podem usar uma integração de armazenamento para armazenar os resultados da consulta em um local do Amazon S3.
Seus usuários podem ter diferentes níveis de acesso a dados confidenciais. Para obter segurança de dados ideal, forneça a cada usuário sua própria integração de armazenamento. Cada integração de armazenamento deve ter a sua própria política de governação de dados.
Esse atributo não está atualmente disponível nas Regiões que optaram por não participar.
O Snowflake requer as seguintes permissões em um bucket e diretório S3 para poder acessar os arquivos no diretório:
+ `s3:GetObject`
+ `s3:GetObjectVersion`
+ `s3:ListBucket`
+ `s3:ListObjects`
+ `s3:GetBucketLocation`
**Criar uma política do IAM**
Você deve criar uma política do IAM para configurar permissões de acesso para o Snowflake carregar e descarregar dados de um bucket do Amazon S3.
A seguir está o documento de política JSON que você usa para criar a política:
```
# Example policy for S3 write access
# This needs to be updated
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject",
"s3:GetObjectVersion",
"s3:DeleteObject",
"s3:DeleteObjectVersion"
],
"Resource": "arn:aws:s3:::bucket/prefix/*"
},
{
"Effect": "Allow",
"Action": [
"s3:ListBucket"
],
"Resource": "arn:aws:s3:::bucket/",
"Condition": {
"StringLike": {
"s3:prefix": ["prefix/*"]
}
}
}
]
}
```
Para obter informações e procedimentos sobre a criação de políticas com documentos de políticas, consulte [Criar políticas do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create.html).
Para obter documentação que fornece uma visão geral do uso de permissões do IAM com Snowflake, consulte os seguintes recursos:
+ [O que é o IAM?](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html)
+ [Crie a função do IAM em AWS](https://docs.snowflake.com/en/user-guide/data-load-s3-config-storage-integration.html#step-2-create-the-iam-role-in-aws)
+ [Crie uma integração de armazenamento em nuvem no Snowflake](https://docs.snowflake.com/en/user-guide/data-load-s3-config-storage-integration.html#step-3-create-a-cloud-storage-integration-in-snowflake)
+ [Recupere o usuário do AWS IAM para sua conta do Snowflake](https://docs.snowflake.com/en/user-guide/data-load-s3-config-storage-integration.html#step-4-retrieve-the-aws-iam-user-for-your-snowflake-account)
+ [Conceda permissões ao usuário do IAM para acessar o bucket.](https://docs.snowflake.com/en/user-guide/data-load-s3-config-storage-integration.html#step-5-grant-the-iam-user-permissions-to-access-bucket-objects)
Para conceder permissão de uso da função Snowflake do cientista de dados para a integração de armazenamento, você deve executar `GRANT USAGE ON INTEGRATION integration_name TO snowflake_role;`.
+ `integration_name` é o nome da sua integração de armazenamento.
+ `snowflake_role` é o nome da função padrão do [Snowflake atribuída](https://docs.snowflake.com/en/user-guide/security-access-control-overview.html#roles) ao usuário cientista de dados.
#### Configurando o Snowflake Access OAuth
Em vez de fazer com que seus usuários insiram suas credenciais diretamente no Data Wrangler, você pode fazer com que eles usem um provedor de identidade para acessar o Snowflake. A seguir estão links para a documentação do Snowflake para os provedores de identidade compatíveis com o Data Wrangler.
+ [Azure AD](https://docs.snowflake.com/en/user-guide/oauth-azure.html)
+ [Okta](https://docs.snowflake.com/en/user-guide/oauth-okta.html)
+ [Ping Federate](https://docs.snowflake.com/en/user-guide/oauth-pingfed.html)
Use a documentação dos links anteriores para configurar o acesso ao seu provedor de identidade. As informações e procedimentos nesta seção ajudam você a entender como usar corretamente a documentação para acessar o Snowflake no Data Wrangler.
Seu provedor de identidade precisa reconhecer o Data Wrangler como uma aplicação. Use o seguinte procedimento para registrar o Data Wrangler como uma aplicação no provedor de identidade:
1. Selecione a configuração que inicia o processo de registro do Data Wrangler como uma aplicação.
1. Forneça aos usuários do provedor de identidade acesso ao Data Wrangler.
1. Ative a autenticação OAuth do cliente armazenando as credenciais do cliente como um AWS Secrets Manager segredo.
1. Especifique um URL de redirecionamento usando o seguinte formato: https://*domain-ID*.studio. *Região da AWS*.sagemaker. aws/jupyter/default/lab
**Importante**
Você está especificando o ID de domínio do Amazon SageMaker AI e Região da AWS que está usando para executar o Data Wrangler.
**Importante**
Você deve registrar uma URL para cada domínio do Amazon SageMaker AI e Região da AWS onde você está executando o Data Wrangler. Usuários de um domínio e Região da AWS que não tenham o redirecionamento URLs configurado para eles não conseguirão se autenticar com o provedor de identidade para acessar a conexão do Snowflake.
1. Certifique-se de que o código de autorização e os tipos de concessão de token de atualização sejam permitidos para a aplicação Data Wrangler.
Em seu provedor de identidade, você deve configurar um servidor que envie OAuth tokens para o Data Wrangler no nível do usuário. O servidor envia os tokens com Snowflake como público.
O Snowflake usa o conceito de papéis que são papéis distintos dos papéis do IAM usados. AWS Você deve configurar o provedor de identidade para usar qualquer função para usar a função padrão associada à conta Snowflake. Por exemplo, se um usuário tiver `systems administrator` o perfil padrão em seu perfil do Snowflake, a conexão do Data Wrangler com o Snowflake será usada como perfil `systems administrator`.
Use o seguinte procedimento para configurar o servidor:
Para configurar o servidor, siga os seguintes passos: Você está trabalhando no Snowflake em todas as etapas, exceto na última.
1. Comece configurando o servidor ou a API.
1. Configure o servidor de autorização para usar o código de autorização e os tipos de concessão do token de atualização.
1. Especifique a vida útil do token de acesso.
1. Defina o tempo limite de inatividade do token de atualização. O tempo limite de inatividade é o tempo em que o token de atualização expira se não for usado.
**nota**
Se você estiver agendando trabalhos no Data Wrangler, recomendamos que o tempo limite de inatividade seja maior que a frequência do trabalho de processamento. Caso contrário, alguns trabalhos de processamento poderão falhar porque o token de atualização expirou antes que pudessem ser executados. Quando o token de atualização expirar, o usuário deverá autenticar novamente acessando a conexão que fez com o Snowflake por meio do Data Wrangler.
1. Especifique `session:role-any` como o novo escopo.
**nota**
Para o Azure AD, copie o identificador exclusivo do escopo. O Data Wrangler exige que você forneça o identificador.
1.
**Importante**
Na Integração de OAuth Segurança Externa do Snowflake, habilite. `external_oauth_any_role_mode`
**Importante**
O Data Wrangler não oferece apoio a tokens de atualização rotativos. O uso de tokens de atualização rotativos pode resultar em falhas de acesso ou na necessidade de login frequente dos usuários.
**Importante**
Se o token de atualização expirar, seus usuários deverão se autenticar novamente acessando a conexão que fizeram com o Snowflake por meio do Data Wrangler.
Depois de configurar o OAuth provedor, você fornece ao Data Wrangler as informações necessárias para se conectar ao provedor. Você pode usar a documentação do seu provedor de identidade para obter valores para os seguintes campos:
+ URL do token: A URL do token que o provedor de identidade envia ao Data Wrangler.
+ URL de autorização: A URL do servidor de autorização do provedor de identidade.
+ ID do cliente: O ID do provedor de identidade.
+ Segredo do cliente: O segredo que somente o servidor de autorização ou a API reconhecem.
+ (Somente Azure AD) As credenciais do OAuth escopo que você copiou.
Você armazena os campos e valores em um AWS Secrets Manager segredo e os adiciona à configuração do ciclo de vida do Amazon SageMaker Studio Classic que você está usando para o Data Wrangler. Uma configuração de duração é um script de shell. Use-o para tornar o nome do recurso da Amazon (ARN) do segredo acessível ao Data Wrangler. Para obter informações sobre a criação de segredos, consulte [Mover segredos codificados](https://docs.aws.amazon.com/secretsmanager/latest/userguide/hardcoded.html) para. AWS Secrets Manager Para obter informações sobre como usar as configurações de ciclo de vida no Studio Classic, consulte [Use configurações de ciclo de vida para personalizar o Amazon Studio Classic SageMaker](studio-lcc.md).
**Importante**
Antes de criar um segredo do Secrets Manager, certifique-se de que a função de execução de SageMaker IA que você está usando para o Amazon SageMaker Studio Classic tenha permissões para criar e atualizar segredos no Secrets Manager. Para obter mais informações sobre como adicionar permissões, consulte [Exemplo: permissão para criar segredos](https://docs.aws.amazon.com/secretsmanager/latest/userguide/auth-and-access_examples.html#auth-and-access_examples_create).
Para Okta e Ping Federate, o seguinte é o formato do segredo:
```
{
"token_url":"https://identityprovider.com/oauth2/example-portion-of-URL-path/v2/token",
"client_id":"example-client-id",
"client_secret":"example-client-secret",
"identity_provider":"OKTA"|"PING_FEDERATE",
"authorization_url":"https://identityprovider.com/oauth2/example-portion-of-URL-path/v2/authorize"
}
```
Para o Azure AD, o formato do segredo é o seguinte:
```
{
"token_url":"https://identityprovider.com/oauth2/example-portion-of-URL-path/v2/token",
"client_id":"example-client-id",
"client_secret":"example-client-secret",
"identity_provider":"AZURE_AD",
"authorization_url":"https://identityprovider.com/oauth2/example-portion-of-URL-path/v2/authorize",
"datasource_oauth_scope":"api://appuri/session:role-any)"
}
```
Você deve ter uma configuração de duração que use o segredo do Secrets Manager que você criou. Você pode criar a configuração de duração ou modificar uma que já tenha sido criada. A configuração deve usar o script a seguir.
```
#!/bin/bash
set -eux
## Script Body
cat > ~/.snowflake_identity_provider_oauth_config <
Esta seção explica como usar AWS PrivateLink para estabelecer uma conexão privada entre o Data Wrangler e o Snowflake. As etapas são explicadas nas seguintes seções:
##### Crie uma VPC
Se você não tiver uma VPC configurada, siga as instruções [Criar uma nova VPC para](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/gsg_create_vpc.html#create_vpc) criar uma.
Depois de escolher uma VPC que você gostaria de usar para estabelecer uma conexão privada, forneça as seguintes credenciais ao administrador do Snowflake para habilitar AWS PrivateLink:
+ ID da VPC
+ AWS ID da conta
+ O URL da sua conta correspondente que você usa para acessar o Snowflake
**Importante**
Conforme descrito na documentação do Snowflake, habilitar sua conta do Snowflake pode levar até dois dias úteis.
##### Configurar a integração com o Snowflake AWS PrivateLink
Depois de AWS PrivateLink ativado, recupere a AWS PrivateLink configuração da sua região executando o comando a seguir em uma planilha do Snowflake. **Faça login no console do Snowflake e insira o seguinte em Planilhas**: `select SYSTEM$GET_PRIVATELINK_CONFIG();`
1. Recupere os valores para o seguinte: `privatelink-account-name`, `privatelink_ocsp-url`, `privatelink-account-url` e `privatelink_ocsp-url` do objeto JSON resultante. O seguinte trecho mostra exemplos de cada valor: Armazene esses valores para uso posterior.
```
privatelink-account-name: xxxxxxxx.region.privatelink
privatelink-vpce-id: com.amazonaws.vpce.region.vpce-svc-xxxxxxxxxxxxxxxxx
privatelink-account-url: xxxxxxxx.region.privatelink.snowflakecomputing.com
privatelink_ocsp-url: ocsp.xxxxxxxx.region.privatelink.snowflakecomputing.com
```
1. Mude para o AWS console e navegue até o menu VPC.
1. No painel do lado esquerdo, escolha o link **Endpoints** para navegar até a configuração dos **endpoints da VPC**.
Uma vez lá, escolha **Criar endpoint**.
1. Selecione o botão de rádio para **Localizar serviço por nome**, conforme mostrado na captura de tela a seguir.
![\[A seção Criar um endpoint no console.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/snowflake-radio.png)
1. No campo **Nome do serviço**, cole o valor `privatelink-vpce-id` que você recuperou na etapa anterior e escolha **Verificar**.
Se a conexão for bem-sucedida, um alerta verde dizendo **Nome do serviço encontrado** aparecerá na tela e as opções de **VPC** e **Sub-rede** se expandirão automaticamente, conforme mostrado na captura de tela a seguir. Dependendo da região de destino, a tela resultante pode mostrar o nome de outra região AWS .
![\[A seção Criar endpoint no console mostrando que a conexão foi bem-sucedida.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/snowflake-service-name-found.png)
1. Selecione a mesma ID da VPC que você enviou para o Snowflake na lista suspensa da **VPC**.
1. Se você ainda não criou uma sub-rede, execute o seguinte conjunto de instruções sobre como criar uma sub-rede:
1. Selecione **Sub-redes** na lista suspensa da **VPC**. Em seguida, selecione **Criar sub-rede** e siga as instruções para criar um subconjunto na sua VPC. Certifique-se de selecionar a VPC ID que você enviou ao Snowflake.
1. Em **Configuração do grupo de segurança**, selecione **Criar novo grupo de segurança** para abrir a tela padrão do **grupo de segurança** em uma nova guia. Nessa nova guia, selecione **Criar grupo de segurança**.
1. Forneça um nome para o novo grupo de segurança (como por exemplo, `datawrangler-doc-snowflake-privatelink-connection`) e uma descrição. Certifique-se de selecionar a VPC ID que você usou nas etapas anteriores.
1. Adicione duas regras para permitir o tráfego de dentro da sua VPC para esse endpoint da VPC.
Navegue até sua VPC VPCs em **Seu** em uma guia separada e recupere seu bloco CIDR para sua VPC. Depois, escolha **Adicionar regras** na seção **Regras de entrda**. Selecione `HTTPS` o tipo, deixe a **Fonte** como **Personalizada** no formulário e cole o valor recuperado da `describe-vpcs` chamada anterior (como `10.0.0.0/16`).
1. Escolha **Criar grupo de segurança**. Recupere a **ID do Grupo de Segurança** do grupo de segurança recém-criado (como `sg-xxxxxxxxxxxxxxxxx`).
1. Na tela de configuração do **endpoint da VPC**, remova o grupo de segurança padrão. Cole o ID do grupo de segurança no campo de pesquisa e marque a caixa de seleção.
![\[A seção Grupo de segurança no console.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/snowflake-security-group.png)
1. Selecione **Criar endpoint**.
1. Se a criação do endpoint for bem-sucedida, você verá uma página com um link para a configuração do seu endpoint da VPC, especificado pelo ID da VPC. Selecione o link para ver a configuração completa.
![\[A seção Detalhes do endpoint.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/snowflake-success-endpoint.png)
Recupere o registro mais alto na lista de nomes DNS. Isso pode ser diferenciado de outros nomes de DNS porque inclui apenas o nome da região (como `us-west-2`) e nenhuma notação de letra da zona de disponibilidade (como `us-west-2a`). Armazene essas informações para uso posterior.
##### Configure o DNS para endpoints do Snowflake em sua VPC
Esta seção explica como configurar o DNS para os endpoints do Snowflake em sua VPC. Isso permite que sua VPC resolva solicitações para o endpoint do AWS PrivateLink Snowflake.
1. Navegue até o [menu Route 53](https://console.aws.amazon.com/route53) em seu AWS console.
1. Selecione a opção **Zonas hospedadas** (se necessário, expanda o menu à esquerda para encontrar essa opção).
1. Escolha **Criar zona hospedada**.
1. No campo **Nome do domínio**, faça referência ao valor armazenado `privatelink-account-url` nas etapas anteriores. Nesse campo, o ID da sua conta do Snowflake é removido do nome DNS e usa somente o valor que começa com o identificador da região. Um **conjunto de registros de recursos** também é criado posteriormente para o subdomínio, como `region.privatelink.snowflakecomputing.com`.
1. Selecione o botão de rádio para **Zona Hospedada Privada** na seção **Tipo**. Seu código de região pode não ser `us-west-2`. Faça referência ao nome DNS devolvido a você pelo Snowflake.
![\[A página Criar zona hospedada no console.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/snowflake-create-hosted-zone.png)
1. Na seção **VPCs Para associar à zona hospedada**, selecione a região na qual sua VPC está localizada e o ID da VPC usado nas etapas anteriores.
![\[A seção VPCs para associar à zona hospedada no console.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/snowflake-vpc-hosted-zone.png)
1. Escolha **Criar zona hospedada**.
1. Em seguida, crie dois registros, um para `privatelink-account-url` e outro para `privatelink_ocsp-url`.
+ No menu **Zona hospedada**, escolha **Criar conjunto de registros**.
1. Em **Nome do registro**, insira somente o ID da sua conta Snowflake (os primeiros 8 caracteres) `privatelink-account-url`.
1. Em **Tipo de registro**, selecione **CNAME**.
1. Em **Valor**, insira o nome DNS do endpoint da VPC regional que você recuperou na última etapa da seção *Configurar a integração AWS PrivateLink com o Snowflake*.
![\[A seção Criação rápida de registro no console.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/snowflake-quick-create-record.png)
1. Escolha **Criar registros**.
1. Repita as etapas anteriores para o registro OCSP como anotamos `privatelink-ocsp-url`, começando com `ocsp` o ID do Snowflake de 8 caracteres para o nome do registro (como) `ocsp.xxxxxxxx`.
![\[A seção Criação rápida de registro no console.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/snowflake-quick-create-ocsp.png)
##### Configurar o endpoint de entrada do Route 53 Resolver para sua VPC
Esta seção explica como configurar os endpoints dos pontos de entrada dos resolvedores do Route 53 para sua VPC.
1. Navegue até o [menu Route 53](https://console.aws.amazon.com/route53) em seu AWS console.
+ No painel esquerdo da seção **Segurança**, selecione a opção **Grupos de segurança**.
1. Escolha **Criar grupo de segurança**.
+ Forneça um nome para o seu grupo de segurança (como por exemplo, `datawranger-doc-route53-resolver-sg`) e uma descrição.
+ Selecione o ID da VPC usado nas etapas anteriores.
+ Crie regras que permitam o DNS sobre UDP e TCP de dentro do bloco CIDR da VPC.
![\[A seção de Regras de entrada no console.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/snowflake-inbound-rules.png)
+ Escolha **Criar grupo de segurança**. Observe o **ID do grupo de segurança** porque adiciona uma regra para permitir o tráfego para o grupo de segurança do endpoint da VPC.
1. Navegue até o [menu Route 53](https://console.aws.amazon.com/route53) em seu AWS console.
+ Na seção **Resolver**, selecione a opção **Endpoint de entrada**.
1. Escolha **Criar endpoint de entrada**.
+ Forneça um nome do endpoint.
+ Na lista suspensa **VPC na região**, selecione a ID da VPC que você usou em todas as etapas anteriores.
+ Na lista suspensa **Grupo de segurança para este endpoint**, selecione o ID do grupo de segurança na Etapa 2 desta seção.
![\[A seção Configurações gerais do endpoint de entrada no console.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/snowflake-inbound-endpoint.png)
+ Na seção **Endereço IP**, selecione uma zona de disponibilidade, selecione uma sub-rede e deixe o seletor de rádio para **Usar um endereço IP selecionado automaticamente** para cada endereço IP.
![\[A seção Endereço IP no console.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/snowflake-ip-address-1.png)
+ Selecione **Enviar**.
1. Selecione o **endpoint de entrada** após sua criação.
1. Depois que o endpoint de entrada for criado, anote os dois endereços IP dos resolvedores.
![\[A seção Endereços IP no console.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/snowflake-ip-addresses-2.png)
##### SageMaker Endpoints de VPC com IA
Esta seção explica como criar VPC endpoints para o seguinte: Amazon SageMaker Studio Classic, SageMaker Notebooks, a SageMaker API, SageMaker Runtime Runtime e Amazon SageMaker Feature Store Runtime.
**Crie um grupo de segurança que seja aplicado a todos os endpoints**.
1. Navegue até o [menu EC2](https://console.aws.amazon.com/ec2) no AWS console.
1. Na seção **Rede e Segurança**, selecione a opção **Grupos de segurança**.
1. Escolha **Criar grupo de segurança**.
1. Forneça um nome e descrição do grupo de segurança (como por exemplo, `datawrangler-doc-sagemaker-vpce-sg`). Uma regra é adicionada posteriormente para permitir o tráfego via HTTPS da SageMaker IA para esse grupo.
**Como criar os endpoints**
1. Navegue até o [menu VPC](https://console.aws.amazon.com/vpc) no AWS console.
1. Selecione a opção **Endpoints**.
1. Escolha **Criar endpoint**.
1. Pesquise o serviço inserindo seu nome no campo **Pesquisar**.
1. Na lista suspensa **VPC**, selecione a VPC na qual sua conexão com o Snowflake existe. AWS PrivateLink
1. Na seção **Sub-redes**, selecione as sub-redes que têm acesso à conexão do Snowflake. PrivateLink
1. Deixe a caixa de seleção **Habilitar nome DNS** marcada.
1. Na seção **Grupos de segurança**, selecione o grupo de segurança que você criou na seção anterior.
1. Escolha **Criar endpoint**.
**Configurar o Studio Classic e o Data Wrangler**
Esta seção explica como configurar o Studio Classic e o Data Wrangler.
1. Configure o grupo de segurança.
1. Navegue até o menu do Amazon EC2 no AWS console.
1. Selecione a opção **Grupos de segurança** na seção **Rede e segurança**.
1. Escolha **Criar grupo de segurança**.
1. Forneça um nome e descrição do seu grupo de segurança (como por exemplo, `datawrangler-doc-sagemaker-studio`).
1. Crie as seguintes regras de entrada:
+ A conexão HTTPS com o grupo de segurança que você provisionou para a PrivateLink conexão do Snowflake que você criou na etapa *Configurar* a integração do Snowflake. PrivateLink
+ A conexão HTTP com o grupo de segurança que você provisionou para a PrivateLink conexão do Snowflake que você criou na etapa *Configurar* a integração do Snowflake. PrivateLink
+ O grupo de segurança UDP e TCP para DNS (porta 53) para o Route 53 Resolver Inbound Endpoint que você cria na etapa 2 de *Configurar o Route 53 Resolver Inbound Endpoint para sua VPC*.
1. Escolha o botão **Criar grupo de segurança** no canto inferior direito.
1. Configure o Studio Classic.
+ Navegue até o menu SageMaker AI no AWS console.
+ No console esquerdo, selecione a opção **SageMaker AI Studio Classic**.
+ Se você não tiver nenhum domínio configurado, o menu **Conceitos básicos** estará presente.
+ Selecione a opção **Configuração padrão** no menu **Conceitos básicos**.
+ No **Método de autenticação**, escolha **AWS Identity and Access Management (IAM)**.
+ No menu **Permissões**, você pode criar uma nova função ou usar uma função preexistente, dependendo do seu caso de uso.
+ Se você escolher **Criar um novo perfil**, você terá a opção de fornecer um nome de bucket do S3 e uma política será gerada para você.
+ Se você já tiver um papel criado com permissões para os buckets do S3 aos quais você precisa de acesso, selecione o papel na lista suspensa. Esse cargo deve ter a política `AmazonSageMakerFullAccess` associada a ele.
+ Selecione a lista suspensa **Rede e Armazenamento** para configurar a VPC, a segurança e as sub-redes que a AI usa. SageMaker
+ Em **VPC, selecione a VPC** na qual sua conexão com o Snowflake existe. PrivateLink
+ Em **Sub-rede (s)**, selecione as sub-redes que têm acesso à conexão do Snowflake. PrivateLink
+ Em **Acesso à rede para o Studio Classic**, selecione **Somente VPC**.
+ Em **Grupo(s) de segurança**, selecione o grupo de segurança que você criou na etapa 1.
+ Selecione **Enviar**.
1. Edite o grupo de segurança de SageMaker IA.
+ Crie as seguintes regras de entrada:
+ Porta 2049 para os grupos de segurança NFS de entrada e saída criados automaticamente pela SageMaker AI na etapa 2 (os nomes dos grupos de segurança contêm o ID de domínio do Studio Classic).
+ Acesso exclusivo a todas as portas TCP (necessário somente para SageMaker IA para VPC).
1. Edite os grupos de segurança do endpoint da VPC:
+ Navegue até o menu do Amazon EC2 no AWS console.
+ Localize o grupo de segurança que você criou na etapa anterior.
+ Adicione uma regra de entrada que permita o tráfego HTTPS do grupo de segurança criado na etapa 1.
1. Crie um perfil de usuário.
+ No **Painel de controle do SageMaker Studio Classic**, escolha **Adicionar usuário**.
+ Forneça um nome de usuário.
+ Em**Função de execução**, escolha criar uma nova função ou usar uma função pré-existente.
+ Se você escolher **Criar um novo perfil**, você terá a opção de fornecer um nome de bucket do Amazon S3 e uma política será gerada para você.
+ Se você já tem uma função criada com permissões para os buckets do Amazon S3 aos quais você precisa de acesso, selecione a função na lista suspensa. Esse cargo deve ter a política `AmazonSageMakerFullAccess` associada a ele.
+ Selecione **Enviar**.
1. Crie um fluxo de dados (siga o guia do cientista de dados descrito na seção anterior).
+ Ao adicionar uma conexão com o Snowflake, insira o valor de `privatelink-account-name` (na etapa *Configurar PrivateLink integração com o Snowflake*) no campo Nome da conta do **Snowflake (alfanumérico), em vez do nome simples da conta** do Snowflake. Todo o resto permanece inalterado.
#### Fornecer informações ao cientista de dados
Forneça ao cientista de dados as informações de que ele precisa para acessar o Snowflake a partir do Amazon SageMaker AI Data Wrangler.
**Importante**
Seus usuários precisam executar o Amazon SageMaker Studio Classic versão 1.3.0 ou posterior. Para obter informações sobre como verificar a versão do Studio Classic e atualizá-la, consulte [Prepare dados de ML com o Amazon SageMaker Data Wrangler](data-wrangler.md).
1. Para permitir que seu cientista de dados acesse o Snowflake a partir do SageMaker Data Wrangler, forneça a ele uma das seguintes opções:
+ Para Autenticação básica, é necessário um nome de conta Snowflake, um nome de usuário e uma senha.
+ Para OAuth, um nome de usuário e senha no provedor de identidade.
+ Para ARN, trata-se do Nome do Recurso da Amazon (ARN) do segredo no Secrets Manager.
+ Um segredo criado com o [Secrets Manager AWS](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) e o ARN do segredo. Use o procedimento abaixo para criar o segredo (secret) para o Snowflake, caso opte por esta opção.
**Importante**
Se seus cientistas de dados usarem a opção **Snowflake Credentials (nome de usuário e senha)** para se conectar ao Snowflake, você poderá usar o [Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) para armazenar as credenciais em segredo. O Secrets Manager alterna os segredos como parte de um plano de segurança de práticas recomendadas. O segredo criado no Secrets Manager só é acessível com a função do Studio Classic configurada quando você definiu um perfil de usuário do Studio Classic. Isso exige que você adicione a permissão, `secretsmanager:PutResourcePolicy`, à política anexada à sua função no Studio Classic.
É altamente recomendável que você delimite a política de função para usar funções diferentes para diferentes grupos de usuários do Studio Classic. Você pode adicionar permissões adicionais baseadas em recursos para os segredos do Secrets Manager. Consulte [Gerenciar política do segredo](https://docs.aws.amazon.com/secretsmanager/latest/userguide/manage_secret-policy.html) para ver as chaves de condição que você pode usar.
Para obter informações sobre como criar um segredo, consulte [Criar um segredo](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html). Você é cobrado pelos segredos que você cria.
1. (Opcional) Forneça ao cientista de dados o nome da integração de armazenamento que você criou usando o seguinte procedimento: [Criar uma integração de armazenamento em nuvem no Snowflake]( https://docs.snowflake.com/en/user-guide/data-load-s3-config-storage-integration.html#step-3-create-a-cloud-storage-integration-in-snowflake). Esse é o nome da nova integração e é chamado `integration_name` no comando SQL do `CREATE INTEGRATION` que você executou, que é mostrado no seguinte trecho:
```
CREATE STORAGE INTEGRATION integration_name
TYPE = EXTERNAL_STAGE
STORAGE_PROVIDER = S3
ENABLED = TRUE
STORAGE_AWS_ROLE_ARN = 'iam_role'
[ STORAGE_AWS_OBJECT_ACL = 'bucket-owner-full-control' ]
STORAGE_ALLOWED_LOCATIONS = ('s3://bucket/path/', 's3://bucket/path/')
[ STORAGE_BLOCKED_LOCATIONS = ('s3://bucket/path/', 's3://bucket/path/') ]
```
### Guia do cientista de dados
Utilize o seguinte para conectar ao Snowflake e acessar seus dados no Data Wrangler:
**Importante**
Seu administrador precisa usar as informações nas seções anteriores para configurar o Snowflake. Se você estiver enfrentando problemas, entre em contato com eles para obter ajuda na solução de problemas.
Você pode se conectar ao Snowflake de uma das seguintes maneiras:
+ Especificar suas credenciais do Snowflake (nome da conta, nome de usuário e senha) no Data Wrangler.
+ Fornecer um nome do recurso da Amazon (ARN) de um segredo que contém as credenciais.
+ Usando um padrão aberto para o provedor de delegação de acesso (OAuth) que se conecta ao Snowflake. Seu administrador pode lhe dar acesso a um dos seguintes OAuth provedores:
+ [Azure AD](https://docs.snowflake.com/en/user-guide/oauth-azure.html)
+ [Okta](https://docs.snowflake.com/en/user-guide/oauth-okta.html)
+ [Ping Federate](https://docs.snowflake.com/en/user-guide/oauth-pingfed.html)
Converse com seu administrador sobre o método que você precisa usar para se conectar ao Snowflake.
As seguintes seções contêm informações sobre como você pode se conectar ao Snowflake usando os métodos mencionados anteriormente:
------
#### [ Specifying your Snowflake Credentials ]
**Para importar um conjunto de dados para o Data Wrangler do Snowflake usando suas credenciais:**
1. Faça login no [Amazon SageMaker AI Console](https://console.aws.amazon.com/sagemaker).
1. Escolha **Studio**.
1. Escolha **Iniciar aplicação**.
1. Na lista suspensa, selecione **Studio**.
1. Escolha o ícone Início.
1. Escolha **Dados**.
1. Escolha **Data Wrangler**.
1. Escolha **Importar dados**.
1. Em **Disponível**, escolha **Snowflake**.
1. Em **Nome da conexão**, especifique um nome que identifique a conexão de forma exclusiva.
1. Em **Método de autenticação**, escolha **Nome e senha do usuário**.
1. Para o **nome da conta do Snowflake (alfanumérico)**, especifique o nome completo da conta do Snowflake.
1. Em **Nome de usuário**, especifique o nome de usuário que você usa para acessar a conta do Snowflake.
1. Em **Senha**, especifique a senha associada ao seu nome de usuário.
1. (Opcional) Para **configurações avançadas**, especifique o seguinte:
+ **Função**: Uma função dentro do Snowflake. Algumas funções têm acesso a conjuntos de dados diferentes. Se você não especificar uma função, o Data Wrangler usará a função padrão em sua conta Snowflake.
+ **Integração de armazenamento**: Quando você especifica e executa uma consulta, o Data Wrangler cria uma cópia temporária dos resultados da consulta na memória. Para armazenar uma cópia permanente dos resultados da consulta, especifique a localização do Amazon S3 para a integração de armazenamento. Seu administrador forneceu a você o URI do S3.
+ **ID da chave KMS**: Uma chave KMS que você criou. Você pode especificar o ARN para criptografar a saída da consulta do Snowflake. Caso contrário, o Data Wrangler usa a criptografia padrão.
1. Selecione **Conectar**.
------
#### [ Providing an Amazon Resource Name (ARN) ]
**Para importar um conjunto de dados para o Data Wrangler do Snowflake usando um ARN:**
1. Faça login no [Amazon SageMaker AI Console](https://console.aws.amazon.com/sagemaker).
1. Escolha **Studio**.
1. Escolha **Iniciar aplicação**.
1. Na lista suspensa, selecione **Studio**.
1. Escolha o ícone Início.
1. Escolha **Dados**.
1. Escolha **Data Wrangler**.
1. Escolha **Importar dados**.
1. Em **Disponível**, escolha **Snowflake**.
1. Em **Nome da conexão**, especifique um nome que identifique a conexão de forma exclusiva.
1. Em **Método de autenticação**, escolha **ARN**.
1. **Secrets Manager ARN** — O ARN do AWS Secrets Manager segredo usado para armazenar as credenciais usadas para se conectar ao Snowflake.
1. (Opcional) Para **configurações avançadas**, especifique o seguinte:
+ **Função**: Uma função dentro do Snowflake. Algumas funções têm acesso a conjuntos de dados diferentes. Se você não especificar uma função, o Data Wrangler usará a função padrão em sua conta Snowflake.
+ **Integração de armazenamento**: Quando você especifica e executa uma consulta, o Data Wrangler cria uma cópia temporária dos resultados da consulta na memória. Para armazenar uma cópia permanente dos resultados da consulta, especifique a localização do Amazon S3 para a integração de armazenamento. Seu administrador forneceu a você o URI do S3.
+ **ID da chave KMS**: Uma chave KMS que você criou. Você pode especificar o ARN para criptografar a saída da consulta do Snowflake. Caso contrário, o Data Wrangler usa a criptografia padrão.
1. Selecione **Conectar**.
------
#### [ Using an OAuth Connection ]
**Importante**
Seu administrador personalizou seu ambiente Studio Classic para fornecer a funcionalidade que você está usando para usar uma OAuth conexão. Você talvez precise reiniciar a aplicação do servidor Jupyter para utilizar essa funcionalidade.
Utilize o procedimento a seguir para atualizar a aplicação do servidor Jupyter.
No Studio Classic, escolha **Arquivo**
Escolha **Desligar**.
Escolha **Desligar o servidor**.
Feche a guia ou janela que você está usando para acessar o Studio Classic.
No console Amazon SageMaker AI, abra o Studio Classic.
**Para importar um conjunto de dados para o Data Wrangler do Snowflake usando suas credenciais:**
1. Faça login no [Amazon SageMaker AI Console](https://console.aws.amazon.com/sagemaker).
1. Escolha **Studio**.
1. Escolha **Iniciar aplicação**.
1. Na lista suspensa, selecione **Studio**.
1. Escolha o ícone Início.
1. Escolha **Dados**.
1. Escolha **Data Wrangler**.
1. Escolha **Importar dados**.
1. Em **Disponível**, escolha **Snowflake**.
1. Em **Nome da conexão**, especifique um nome que identifique a conexão de forma exclusiva.
1. Em **Método de autenticação**, escolha **OAuth**.
1. (Opcional) Para **configurações avançadas**, especifique o seguinte:
+ **Função**: Uma função dentro do Snowflake. Algumas funções têm acesso a conjuntos de dados diferentes. Se você não especificar uma função, o Data Wrangler usará a função padrão em sua conta Snowflake.
+ **Integração de armazenamento**: Quando você especifica e executa uma consulta, o Data Wrangler cria uma cópia temporária dos resultados da consulta na memória. Para armazenar uma cópia permanente dos resultados da consulta, especifique a localização do Amazon S3 para a integração de armazenamento. Seu administrador forneceu a você o URI do S3.
+ **ID da chave KMS**: Uma chave KMS que você criou. Você pode especificar o ARN para criptografar a saída da consulta do Snowflake. Caso contrário, o Data Wrangler usa a criptografia padrão.
1. Selecione **Conectar**.
------
Você pode iniciar o processo de importação dos seus dados do Snowflake depois de ter se conectado a ele.
Dentro do Data Wrangler, você pode visualizar seus data warehouses, bancos de dados e esquemas, juntamente com o ícone de olho com o qual você pode visualizar a tabela. Depois de selecionar o ícone **Visualizar tabela**, a visualização do esquema dessa tabela é gerada. Você deve selecionar um depósito antes de poder visualizar uma tabela.
**Importante**
Se você estiver importando um conjunto de dados com colunas do tipo `TIMESTAMP_TZ` ou `TIMESTAMP_LTZ`, adicione `::string` aos nomes das colunas da sua consulta. Para obter mais informações, consulte [Como descarregar dados TIMESTAMP\$1TZ e TIMESTAMP\$1LTZ em um arquivo Parquet](https://community.snowflake.com/s/article/How-To-Unload-Timestamp-data-in-a-Parquet-file).
Após selecionar um data warehouse, banco de dados e esquema, agora você pode escrever consultas e executá-las. A saída da sua consulta é exibida em **Resultados da consulta**.
Depois de definir a saída da sua consulta, você poderá importar a saída da sua consulta para um fluxo do Data Wrangler para realizar transformações de dados.
Depois de importar seus dados, navegue até o fluxo do Data Wrangler e comece a adicionar transformações a ele. Para ver uma lista das transformações disponíveis, consulte [Transformar dados](data-wrangler-transform.md).
## Importar dados de plataformas de software como serviço (SaaS)
Você pode usar o Data Wrangler para importar dados de mais de quarenta plataformas de software como serviço (SaaS). Para importar seus dados da sua plataforma SaaS, você ou seu administrador devem usar AppFlow a Amazon para transferir os dados da plataforma para o Amazon S3 ou o Amazon Redshift. Para obter mais informações sobre a Amazon AppFlow, consulte [O que é a Amazon AppFlow?](https://docs.aws.amazon.com/appflow/latest/userguide/what-is-appflow.html) Se você não precisar usar o Amazon Redshift, recomendamos transferir os dados para o Amazon S3 para simplificar o processo.
O Data Wrangler é compatível com a transferência de dados das seguintes plataformas SaaS:
+ [Amplitude](https://docs.aws.amazon.com/appflow/latest/userguide/amplitude.html)
+ [Asana](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-asana.html)
+ [Braintree](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-braintree.html)
+ [CircleCI](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-circleci.html)
+ [DocuSign Monitorar](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-docusign-monitor.html)
+ [Delighted](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-delighted.html)
+ [Domo](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-domo.html)
+ [Datadog](https://docs.aws.amazon.com/appflow/latest/userguide/datadog.html)
+ [Dynatrace](https://docs.aws.amazon.com/appflow/latest/userguide/dynatrace.html)
+ [Facebook Ads](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-facebook-ads.html)
+ [Facebook Page Insights](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-facebook-page-insights.html)
+ [Google Ads](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-google-ads.html)
+ [Google Analytics 4](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-google-analytics-4.html)
+ [Google Calendar](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-google-calendar.html)
+ [Google Search Console](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-google-search-console.html)
+ [GitHub](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-github.html)
+ [GitLab](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-gitlab.html)
+ [Infor Nexus](https://docs.aws.amazon.com/appflow/latest/userguide/infor-nexus.html)
+ [Instagram Ads](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-instagram-ads.html)
+ [Intercom](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-intercom.html)
+ [JDBC (sincronização)](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-jdbc.html)
+ [Jira Cloud](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-jira-cloud.html)
+ [LinkedIn Anúncios](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-linkedin-ads.html)
+ [Mailchimp](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-mailchimp.html)
+ [Marketo](https://docs.aws.amazon.com/appflow/latest/userguide/marketo.html)
+ [Microsoft Dynamics 365](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-microsoft-dynamics-365.html)
+ [Microsoft Teams](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-microsoft-teams.html)
+ [Mixpanel](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-mixpanel.html)
+ [Okta](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-okta.html)
+ [Oracle HCM](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-oracle-hcm.html)
+ [Paypal Checkout](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-paypal.html)
+ [Pendo](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-pendo.html)
+ [Salesforce](https://docs.aws.amazon.com/appflow/latest/userguide/salesforce.html)
+ [Salesforce Marketing Cloud](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-salesforce-marketing-cloud.html)
+ [Salesforce Pardot](https://docs.aws.amazon.com/appflow/latest/userguide/pardot.html)
+ [SAP OData](https://docs.aws.amazon.com/appflow/latest/userguide/sapodata.html)
+ [SendGrid](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-sendgrid.html)
+ [ServiceNow](https://docs.aws.amazon.com/appflow/latest/userguide/servicenow.html)
+ [Singular](https://docs.aws.amazon.com/appflow/latest/userguide/singular.html)
+ [Slack](https://docs.aws.amazon.com/appflow/latest/userguide/slack.html)
+ [Smartsheet](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-smartsheet.html)
+ [Snapchat Ads](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-snapchat-ads.html)
+ [Stripe](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-stripe.html)
+ [Trend Micro](https://docs.aws.amazon.com/appflow/latest/userguide/trend-micro.html)
+ [Typeform](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-typeform.html)
+ [Veeva](https://docs.aws.amazon.com/appflow/latest/userguide/veeva.html)
+ [WooCommerce](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-woocommerce.html)
+ [Zendesk](https://docs.aws.amazon.com/appflow/latest/userguide/slack.html)
+ [Zendesk Chat](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-zendesk-chat.html)
+ [Zendesk Sell](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-zendesk-sell.html)
+ [Zendesk Sunshine](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-zendesk-sunshine.html)
+ [Zoho CRM](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-zoho-crm.html)
+ [Zoom Meetings](https://docs.aws.amazon.com/appflow/latest/userguide/connectors-zoom-meetings.html)
A lista anterior tem links para mais informações sobre como configurar sua fonte de dados. Você ou seu administrador podem consultar os links anteriores depois de terem lido as informações a seguir.
Ao navegar até a guia **Importar** do seu fluxo do Data Wrangler, você vê as fontes de dados nas seguintes seções:
+ **Disponível**
+ **Configure as fontes de dados**
Você pode se conectar às fontes de dados em **Disponível** sem precisar de configuração adicional. Você pode escolher a fonte de dados e importar seus dados.
Fontes de dados, em **Configurar fontes de dados**, exigem que você ou seu administrador usem a Amazon AppFlow para transferir os dados da plataforma SaaS para o Amazon S3 ou o Amazon Redshift. Para obter informações sobre como realizar uma transferência, consulte [Usando AppFlow a Amazon para transferir seus dados](#data-wrangler-import-saas-transfer).
Depois de realizar a transferência de dados, a plataforma SaaS aparece como uma fonte de dados em **Disponível**. Você pode escolhê-lo e importar os dados que você transferiu para o Data Wrangler. Os dados que você transferiu aparecem como tabelas que você pode consultar.
### Usando AppFlow a Amazon para transferir seus dados
AppFlow A Amazon é uma plataforma que você pode usar para transferir dados da sua plataforma SaaS para o Amazon S3 ou o Amazon Redshift sem precisar escrever nenhum código. Para realizar uma transferência de dados, você usa o Console de gerenciamento da AWS.
**Importante**
Você deve se certificar de que configurou as permissões para realizar uma transferência de dados. Para obter mais informações, consulte [AppFlow Permissões da Amazon](data-wrangler-security.md#data-wrangler-appflow-permissions).
Depois de adicionar as permissões, você pode transferir os dados. Na Amazon AppFlow, você cria um *fluxo* para transferir os dados. Um fluxo é uma série de configurações. Você pode usá-lo para especificar se está executando a transferência de dados em um cronograma ou se está particionando os dados em arquivos separados. Após ter configurado o fluxo, você o executa para transferir os dados.
Para obter informações sobre a criação de um fluxo, consulte [Criação de fluxos na Amazon AppFlow](https://docs.aws.amazon.com/appflow/latest/userguide/create-flow.html). Para obter informações sobre como executar um fluxo, consulte [Ativar um AppFlow fluxo da Amazon](https://docs.aws.amazon.com/appflow/latest/userguide/run-flow.html).
Depois que os dados forem transferidos, use o seguinte procedimento para acessar os dados no Data Wrangler:
**Importante**
Antes de tentar acessar seus dados, certifique-se de que seu perfil do IAM tenha a seguinte política:
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "glue:SearchTables",
"Resource": [
"arn:aws:glue:*:*:table/*/*",
"arn:aws:glue:*:*:database/*",
"arn:aws:glue:*:*:catalog"
]
}
]
}
```
Por padrão, o perfil do IAM que você usa para acessar o Data Wrangler é o `SageMakerExecutionRole`. Para obter mais informações sobre a adição de políticas, consulte [Adicionar permissões de identidades do IAM (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html#add-policies-console).
Para estabelecer conexão com uma fonte de dados, siga os seguintes passos:
1. Faça login no [Amazon SageMaker AI Console](https://console.aws.amazon.com/sagemaker).
1. Escolha **Studio**.
1. Escolha **Iniciar aplicação**.
1. Na lista suspensa, selecione **Studio**.
1. Escolha o ícone Início.
1. Escolha **Dados**.
1. Escolha **Data Wrangler**.
1. Escolha **Importar dados**.
1. Em **Disponível**, escolha a fonte de dados.
1. Para o campo **Nome**, especifique o nome da conexão.
1. (Opcional) Escolha **Configuração avançada**.
1. Escolha um **Grupo de trabalho**.
1. Se seu grupo de trabalho não impôs o local de saída do Amazon S3 ou se você não usa um grupo de trabalho, especifique um valor para a **localização dos resultados da consulta no Amazon S3**.
1. (Opcional) Em **Período de retenção de dados**, marque a caixa de seleção para definir um período de retenção de dados e especificar o número de dias para armazenar os dados antes de serem excluídos.
1. (Opcional) Por padrão, o Data Wrangler salva a conexão. Você pode optar por desmarcar a caixa de seleção e não salvar a conexão.
1. Selecione **Conectar**.
1. Especifique uma consulta.
**nota**
Para ajudá-lo a especificar uma consulta, você pode escolher uma tabela no painel de navegação esquerdo. O Data Wrangler mostra o nome da tabela e uma visualização prévia da tabela. Clique no ícone ao lado do nome da tabela para copiá-lo. Você pode usar o nome da tabela na consulta.
1. Escolha **Executar**.
1. Escolha **Importar consulta**.
1. Em **nome do conjunto de dados**, especifique o nome do conjunto de dados.
1. Escolha **Adicionar**.
Ao navegar até a tela **Importar dados**, você pode ver a conexão que você criou. Você pode usar a conexão para importar mais dados.
## Armazenamento de dados importados
**Importante**
É altamente recomendável que você siga as melhores práticas para proteger seu bucket do Amazon S3 seguindo as [melhores práticas de segurança](https://docs.aws.amazon.com/AmazonS3/latest/userguide/security-best-practices.html).
Quando você consulta dados do Amazon Athena ou do Amazon Redshift, o conjunto de dados consultado é automaticamente armazenado no Amazon S3. Os dados são armazenados no bucket padrão do SageMaker AI S3 para a AWS região na qual você está usando o Studio Classic.
Os buckets do S3 padrão têm a seguinte convenção de nomenclatura: `sagemaker-region-account number`. Por exemplo, se o número da sua conta for 111122223333 e você estiver usando o Studio Classic em `us-east-1`, seus conjuntos de dados importados serão armazenados em 111122223333 `sagemaker-us-east-1-`.
Os fluxos do Data Wrangler dependem desta localização de conjunto de dados no Amazon S3, portanto, você não deve modificar este conjunto de dados no Amazon S3 enquanto estiver usando um fluxo dependente. Se você modificar esta localização no S3 e desejar continuar usando seu fluxo de dados, será necessário remover todos os objetos em `trained_parameters` no seu arquivo .flow. Para fazer isso, baixe o arquivo .flow do Studio Classic e, para cada instância do `trained_parameters`, exclua todas as entradas. Quando terminar, o `trained_parameters` deve ser um objeto JSON vazio:
```
"trained_parameters": {}
```
Quando você exporta e utiliza seu fluxo de dados para processar seus dados, o arquivo .flow que você exporta faz referência a este conjunto de dados no Amazon S3. Consulte as seguintes seções para saber mais:
### Armazenamento de importação do Amazon Redshift
O Data Wrangler armazena os conjuntos de dados resultantes da sua consulta em um arquivo Parquet em seu bucket AI S3 padrão SageMaker .
Esse arquivo é armazenado sob o seguinte prefixo (diretório): redshift/ *uuid* /data/, onde *uuid* é um identificador exclusivo criado para cada consulta.
Por exemplo, se seu bucket padrão for`sagemaker-us-east-1-111122223333`, um único conjunto de dados consultado no Amazon Redshift está localizado em s3://-1-111122223333/redshift/ /data/. sagemaker-us-east *uuid*
### Importar e armazenar do Amazon Athena
Quando você consulta um banco de dados do Athena e importa um conjunto de dados, o Data Wrangler armazena o conjunto de dados, bem como um subconjunto desse conjunto de dados, ou *arquivos de pré-visualização*, no Amazon S3.
O conjunto de dados que você importa ao selecionar **Importar conjunto de dados** é armazenado no formato Parquet no Amazon S3.
Os arquivos de visualização são gravados no formato CSV quando você seleciona **Executar** na tela de importação do Athena e contêm até 100 linhas do conjunto de dados consultado.
O conjunto de dados que você consulta está localizado sob o prefixo (diretório): athena/ *uuid* /data/, onde *uuid* está um identificador exclusivo criado para cada consulta.
Por exemplo, se seu bucket padrão for`sagemaker-us-east-1-111122223333`, um único conjunto de dados consultado do Athena está localizado em /athena/ /data/. `s3://sagemaker-us-east-1-111122223333` *uuid* *example\$1dataset.parquet*
O subconjunto do conjunto de dados armazenado para visualizar dataframes no Data Wrangler é armazenado sob o prefixo: athena/.
# Crie e use um fluxo do Data Wrangler
Use um fluxo do Amazon SageMaker Data Wrangler, ou um fluxo de *dados*, para criar e modificar um pipeline de preparação de dados. O fluxo de dados conecta os conjuntos de dados, as transformações e as análises, ou *etapas*, que você cria e pode ser usado para definir seu pipeline.
## Instâncias
Quando você cria um fluxo do Data Wrangler no Amazon SageMaker Studio Classic, o Data Wrangler usa uma instância do Amazon EC2 para executar as análises e transformações no seu fluxo. Por padrão, o Data Wrangler usa a instância m5.4xlarge. As instâncias m5 são instâncias de uso geral que fornecem um equilíbrio entre computação e memória. Você pode usar instâncias m5 para uma variedade de workloads computacionais.
O Data Wrangler também oferece a opção de usar instâncias r5. As instâncias r5 são projetadas para oferecer desempenho rápido que processa grandes conjuntos de dados na memória.
Recomendamos que você escolha uma instância que seja melhor otimizada para suas workloads. Por exemplo, o r5.8xlarge pode ter um preço mais alto do que o m5.4xlarge, mas o r5.8xlarge pode ser melhor otimizado para suas workloads. Com instâncias mais otimizadas, você pode executar seus fluxos de dados em menos tempo e a um custo menor.
A tabela a seguir mostra as instâncias que você pode usar para executar seu fluxo do Data Wrangler.
| Instâncias padrão | vCPU | Memória |
| --- | --- | --- |
| ml.m5.4xlarge | 16 | 64 GiB |
| ml.m5.8xlarge | 32 | 128 GiB |
| ml.m5.16xlarge | 64 | 256 GiB |
| ml.m5.24xlarge | 96 | 384 GiB |
| r5.4xlarge | 16 | 128 GiB |
| r5.8xlarge | 32 | 256 GiB |
| r5.24xlarge | 96 | 768 GiB |
Para obter mais informações sobre instâncias r5, consulte [Instâncias R5 do Amazon EC2](https://aws.amazon.com/ec2/instance-types/r5/). Para obter mais informações sobre instâncias m5, consulte [Instâncias M5 do Amazon EC2](https://aws.amazon.com/ec2/instance-types/m5/).
Cada fluxo do Data Wrangler tem uma instância do Amazon EC2 associada a ele. Você pode ter vários fluxos associados a uma única instância.
Para cada arquivo de fluxo, você pode alternar facilmente o tipo de instância. Se você alternar o tipo de instância, a instância que você usou para executar o fluxo continuará sendo executada.
Para mudar o tipo de instância do seu fluxo, faça o seguinte:
1. Escolha o ícone **Terminais e kernels em execução** (![\[Black square icon representing a placeholder or empty image.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/icons/running-terminals-kernels.png)).
1. Navegue até a instância que você está usando e escolha-a.
1. Escolha o tipo de instância que você deseja excluir.
![\[Exemplo mostrando como escolher uma instância na página de fluxo de dados do console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/data-wrangler-instance-switching-list-instances.png)
1. Escolha **Salvar**.
Você é cobrado por todas as instâncias em execução. Para evitar cobranças adicionais, encerre as instâncias que você não está usando manualmente. Para encerrar uma instância em execução, use o procedimento a seguir.
Para encerrar uma instância em execução.
1. Escolha o ícone de instância. A imagem a seguir mostra onde selecionar o ícone **RUNNING INSTANCES**.
![\[\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/instance-switching-running-instances.png)
1. Escolha **Encerrar** ao lado da instância que você deseja encerrar.
Se você encerrar uma instância usada para executar um fluxo, não poderá acessar temporariamente o fluxo. Se você receber um erro ao tentar abrir o fluxo executando uma instância que você desligou anteriormente, aguarde 5 minutos e tente abri-lo novamente.
Quando você exporta seu fluxo de dados para um local como o Amazon Simple Storage Service ou o Amazon SageMaker Feature Store, o Data Wrangler executa um trabalho de SageMaker processamento da Amazon. Você pode usar uma das instâncias a seguir para o trabalho de processamento. Para obter mais informações na exportação dos seus dados, consulte [Exportar](data-wrangler-data-export.md).
| Instâncias padrão | vCPU | Memória |
| --- | --- | --- |
| ml.m5.4xlarge | 16 | 64 GiB |
| ml.m5.12xlarge | 48 | 192 GiB |
| ml.m5.24xlarge | 96 | 384 GiB |
Para obter mais informações sobre o custo por hora do uso dos tipos de instância disponíveis, consulte [SageMaker Preços](https://aws.amazon.com//sagemaker/pricing/).
## A interface de usuário do fluxo de dados
Quando você importa um conjunto de dados, o conjunto de dados original aparece no fluxo de dados e é chamado de **Fonte**. Se você ativou a amostragem ao importar seus dados, esse conjunto de dados será denominado **Fonte - amostrado**. O Data Wrangler infere automaticamente os tipos de cada coluna em seu conjunto de dados e cria um novo quadro de dados chamado **Tipos de dados**. Você pode selecionar esse quadro para atualizar os tipos de dados inferidos. Você verá resultados semelhantes aos mostrados na imagem a seguir após o upload de um conjunto de dados:
![\[Exemplo mostrando a Fonte: com amostra e Tipos de dados no console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/dataflow-after-import.png)
Cada vez que você adiciona uma etapa de transformação, você cria um novo dataframe. Quando várias etapas de transformação (exceto **Unir** ou **Concatenar**) são adicionadas ao mesmo conjunto de dados, elas são empilhadas.
**Unir** e **Concatenar** criam etapas autônomas que contêm o novo conjunto de dados unido ou concatenado.
O diagrama a seguir mostra um fluxo de dados com uma junção entre dois conjuntos de dados, bem como duas pilhas de etapas. A primeira pilha (**Etapas (2)** adiciona duas transformações ao tipo inferido no conjunto de dados **tipos de dados**. A pilha *downstream*, ou a pilha à direita, adiciona transformações ao conjunto de dados resultantes de uma junção chamada **demo-join.**
![\[Exemplo mostrando etapas na página de fluxo de dados do console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/data-flow-steps.png)
A pequena caixa cinza no canto inferior direito do fluxo de dados fornece uma visão geral do número de pilhas e etapas no fluxo e do layout do fluxo. A caixa mais clara dentro da caixa cinza indica as etapas que estão dentro da visualização da interface do usuário. Você pode usar essa caixa para ver seções do seu fluxo de dados que estão fora da visualização da interface do usuário. Use o ícone de ajuste da tela (![\[Dotted square outline icon representing a placeholder or empty state.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/updates/fit-screen.png)) para ajustar todas as etapas e conjuntos de dados à sua visualização da interface do usuário.
A barra de navegação inferior esquerda inclui ícones que você pode usar para ampliar (![\[Plus symbol icon representing an addition or new item action.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/updates/zoom-in.png)) e reduzir (![\[Horizontal line or divider, typically used to separate content sections.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/updates/zoom-out.png)) o fluxo de dados, além de redimensionar o fluxo de dados para caber na tela (![\[Dotted square outline icon representing a placeholder or empty state.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/updates/fit-screen.png)). Use o ícone de cadeado (![\[Trash can icon representing deletion or removal functionality.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/updates/lock-nodes.png)) para bloquear e desbloquear a localização de cada etapa na tela.
## Adicione uma etapa ao seu fluxo de dados
Selecione **\$1** ao lado de qualquer conjunto de dados ou etapa adicionada anteriormente e, em seguida, selecione uma das seguintes opções:
+ **Editar tipos de dados** (somente para uma etapa **de tipos de dados**): se você não adicionou nenhuma transformação a uma **etapa de tipos de dados**, você pode selecionar **Editar tipos de dados** para atualizar os tipos de dados que o Data Wrangler inferiu ao importar seu conjunto de dados.
+ **Adicionar transformação**: adiciona uma nova etapa de transformação. Consulte [Transformar dados](data-wrangler-transform.md) para saber mais sobre as transformações de dados que você pode adicionar.
+ **Adicionar análise**: adiciona uma análise. Você pode usar essa opção para analisar seus dados em qualquer ponto do fluxo de dados. Quando você adiciona uma ou mais análises a uma etapa, um ícone de análise (![\[Bar chart icon representing data visualization or analytics functionality.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/updates/analysis-icon.png)) aparece nessa etapa. Consulte [Analisar e visualizar](data-wrangler-analyses.md) para saber mais sobre as análises que você pode adicionar.
+ **Unir**: une dois conjuntos de dados e adiciona o conjunto de dados resultante ao fluxo de dados. Para saber mais, consulte [Unir conjuntos de dados](data-wrangler-transform.md#data-wrangler-transform-join).
+ **Concatenar**: concatena dois conjuntos de dados e adiciona o conjunto de dados resultante ao fluxo de dados. Para saber mais, consulte [Concatenar conjuntos de dados](data-wrangler-transform.md#data-wrangler-transform-concatenate).
## Excluir uma etapa do seu fluxo de dados
Para excluir uma etapa, selecione a etapa e depois **Excluir**. Se o nó for de uma única entrada, você exclui somente a etapa selecionada. Quando se exclui uma etapa com uma única entrada não se exclui as etapas que a seguem. Se você excluir uma etapa de um nó de origem, junção ou concatenação, todas as etapas subsequentes também serão excluídas.
Para excluir uma etapa de uma pilha de etapas, selecione a pilha e, em seguida, selecione a etapa que deseja excluir.
Você pode usar um dos procedimentos a seguir para excluir uma etapa sem excluir as etapas posteriores.
------
#### [ Delete a step in the Data Wrangler flow ]
Você pode excluir uma etapa individual para nós em seu fluxo de dados que tenham uma única entrada. Você não pode excluir etapas individuais dos nós de origem, união e concatenação.
Use o procedimento a seguir para excluir uma etapa no fluxo do Data Wrangler.
1. Escolha o grupo de etapas que contém a etapa que você está excluindo.
1. Escolha o ícone próximo à etapa.
1. Escolha **Excluir etapa**.
![\[Exemplo de como excluir uma etapa na página de fluxo de dados do console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/delete-step-flow-1.png)
------
#### [ Delete a step in the table view ]
Use o procedimento a seguir para excluir uma etapa na exibição de tabela.
Você pode excluir uma etapa individual para nós em seu fluxo de dados que tenham uma única entrada. Você não pode excluir etapas individuais dos nós de origem, união e concatenação.
1. Escolha a etapa e abra a exibição de tabela da etapa.
1. Mova o cursor sobre a etapa para que o ícone de reticências apareça.
1. Escolha o ícone próximo à etapa.
1. Escolha **Excluir**.
![\[Exemplo de como excluir uma etapa na exibição de tabela do console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/delete-step-table-0.png)
------
## Exclua uma etapa no seu fluxo do Data Wrangler.
Você pode editar cada etapa adicionada ao fluxo do Data Wrangler. Ao editar as etapas, é possível alterar as transformações ou os tipos de dados das colunas. Você pode editar as etapas para fazer alterações com as quais pode realizar análises melhores.
Há várias maneiras de editar uma etapa. Alguns exemplos incluem a alteração do método de imputação ou a alteração do limite para considerar um valor como algo atípico.
Utilize o seguinte procedimento para editar uma etapa:
Para editar uma etapa, faça o seguinte:
1. Escolha uma etapa no fluxo do Data Wrangler para abrir a exibição da tabela.
![\[Exemplo de etapa na página de fluxo de dados do console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/data-flow-edit-choose-step.png)
1. Escolha uma etapa no fluxo de dados.
1. Edite a etapa.
A imagem a seguir mostra um exemplo de edição de uma etapa.
![\[Exemplo mostrando como editar etapas na página de fluxo de dados do console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/data-flow-table-edit-step.png)
**nota**
Você pode usar os espaços compartilhados em seu domínio Amazon SageMaker AI para trabalhar de forma colaborativa em seus fluxos do Data Wrangler. Em um espaço compartilhado, você e seus colaboradores podem editar um arquivo de fluxo em tempo real. No entanto, nem você nem seus colaboradores podem ver as mudanças em tempo real. Quando alguém faz uma alteração no fluxo do Data Wrangler, deve salvá-la imediatamente. Quando alguém salva um arquivo, um colaborador não poderá vê-lo, a menos que feche o arquivo e o reabra. Todas as alterações que não são salvas por uma pessoa são substituídas pela pessoa que salvou as alterações.
# Obtenha insights sobre dados e qualidade dos dados
Use o **Relatório de qualidade dos dados e insights** para realizar uma análise dos dados que você importou para o Data Wrangler. Recomendamos que você crie o relatório após importar o conjunto de dados. Você pode usar o relatório para ajudar você a limpar e processar seus dados. Ele fornece informações como o número de valores ausentes e o número de valores atípicos. Caso tenha problemas com seus dados, como vazamento ou desequilíbrio de destino, o relatório de insights pode chamar sua atenção para esses problemas.
Use o procedimento a seguir para criar um relatório de qualidade dos dados e insights. Ele pressupõe que você já tenha importado um conjunto de dados para o fluxo do Data Wrangler.
**Para criar um relatório de qualidade dos dados e insights**
1. Escolha um **\$1** próximo ao um nó em seu fluxo do Data Wrangler.
1. Selecione **Obter insights de dados**.
1. Em **Nome da análise**, especifique um nome para o relatório de insights.
1. (Opcional) Para **Coluna de destino**, especifique a coluna de destino.
1. Para **Tipo de problema**, especifique **Regressão** ou **Classificação**.
1. Para **Tamanho dos dados**, especifique uma das seguintes opções:
+ **50 mil**: Usa as primeiras 50000 linhas do conjunto de dados que você importou para criar o relatório.
+ **Conjunto de dados inteiro**: Usa o conjunto de dados inteiro que você importou para criar o relatório.
**nota**
A criação de um relatório de qualidade de dados e insights sobre todo o conjunto de dados usa um trabalho de SageMaker processamento da Amazon. Um trabalho SageMaker de processamento provisiona os recursos computacionais adicionais necessários para obter insights sobre todos os seus dados. Para obter mais informações sobre trabalhos SageMaker de processamento, consulte[Cargas de trabalho de transformação de dados com processamento SageMaker](processing-job.md).
1. Escolha **Criar**.
Os tópicos a seguir mostram as seções do relatório:
**Topics**
+ [Resumo](#data-wrangler-data-insights-summary)
+ [Coluna de destino](#data-wrangler-data-insights-target-column)
+ [Modelo rápido](#data-wrangler-data-insights-quick-model)
+ [Resumo de atributos](#data-wrangler-data-insights-feature-summary)
+ [Amostras](#data-wrangler-data-insights-samples)
+ [Definições](#data-wrangler-data-insights-definitions)
Você pode fazer download do relatório ou visualizá-lo online. Para fazer download do relatório, escolha o botão de download no canto superior direito da tela. A imagem a seguir mostra o botão.
![\[Exemplo mostrando o botão de download.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/data-insights/data-insights-download.png)
## Resumo
O relatório de insights tem um breve resumo dos dados que inclui informações gerais, como valores ausentes, valores inválidos, tipos de atributos, contagens de valores atípicos e muito mais. Ele também pode incluir avisos de severidade alta que apontam para prováveis problemas com os dados. Recomendamos que você investigue os avisos.
Veja a seguir um exemplo de um resumo de relatório.
![\[Exemplo de resumo do relatório.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/data-insights/data-insights-report-summary.png)
## Coluna de destino
Quando você cria o relatório de qualidade dos dados e insights, o Data Wrangler oferece a opção de selecionar uma coluna de destino. Uma coluna de destino é uma coluna que você está tentando prever. Quando você escolhe uma coluna de destino, o Data Wrangler cria automaticamente uma análise da coluna de destino. Ele também classifica os atributos na ordem de seu poder preditivo. Ao selecionar uma coluna de destino, você deve especificar se está tentando resolver um problema de regressão ou classificação.
Para classificação, o Data Wrangler mostra uma tabela e um histograma das classes mais comuns. Uma classe é uma categoria. Ele também apresenta observações, ou linhas, com um valor de destino ausente ou inválido.
A imagem a seguir mostra um exemplo de análise de coluna de destino para um problema de classificação.
![\[Exemplo de análise da coluna-alvo.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/data-insights/data-insights-target-column-classification.png)
Para regressão, o Data Wrangler mostra um histograma de todos os valores na coluna de destino. Ele também apresenta observações, ou linhas, com um valor de destino ausente, inválido ou atípico.
A imagem a seguir mostra um exemplo de análise de coluna de destino para um problema de regressão.
![\[Exemplo de análise da coluna-alvo.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/data-insights/data-insights-target-column-regression.png)
## Modelo rápido
O **modelo rápido** fornece uma estimativa da qualidade prevista esperada de um modelo que você treina em seus dados.
O Data Wrangler divide seus dados em folds de treinamento e validação. Ele usa 80% das amostras para treinamento e 20% dos valores para validação. Para classificação, a amostra é dividida estratificada. Para uma divisão estratificada, cada partição de dados tem a mesma proporção de rótulos. Para problemas de classificação, é importante ter a mesma proporção de rótulos entre os folds de treinamento e classificação. O Data Wrangler treina o XGBoost modelo com os hiperparâmetros padrão. Ele aplica a interrupção antecipada dos dados de validação e executa o mínimo de pré-processamento de atributos.
Para modelos de classificação, o Data Wrangler retorna um resumo do modelo e uma matriz de confusão.
Este é um exemplo de resumo de modelo de classificação. Para saber mais sobre as informações que ele retorna, consulte [Definições](#data-wrangler-data-insights-definitions).
![\[Exemplo de resumo do modelo de classificação.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/data-insights/data-insights-quick-model-classification-summary.png)
Este é um exemplo de matriz de confusão que o modelo rápido retorna.
![\[Exemplo de matriz de confusão.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/data-insights/data-insights-quick-model-classification-confusion-matrix.png)
Uma matriz de confusão fornece as seguintes informações:
+ O número de vezes que o rótulo previsto corresponde ao rótulo verdadeiro.
+ O número de vezes que o rótulo previsto não corresponde ao rótulo verdadeiro.
O rótulo verdadeiro representa uma observação real em seus dados. Por exemplo, se você está usando um modelo para detectar transações fraudulentas, o rótulo verdadeiro representa uma transação que é realmente fraudulenta ou não fraudulenta. O rótulo previsto representa o rótulo que seu modelo atribui aos dados.
Você pode usar a matriz de confusão para ver o quão bem o modelo prevê a presença ou a ausência de uma condição. Se você está prevendo transações fraudulentas, pode usar a matriz de confusão para ter uma ideia da sensibilidade e da especificidade do modelo. A sensibilidade se refere à capacidade do modelo de detectar transações fraudulentas. A especificidade se refere à capacidade do modelo de evitar a detecção de transações não fraudulentas como fraudulentas.
Este é um exemplo de resultados do modelo rápido para um problema de regressão.
![\[Exemplo de saídas do modelo rápido para um problema de regressão.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/data-insights/data-insights-quick-model-regression-summary.png)
## Resumo de atributos
Quando você especifica uma coluna de destino, o Data Wrangler ordena os atributos de acordo com seu poder de predição. O poder de predição é medido nos dados após serem divididos em folds de 80% de treinamento e 20% de validação. O Data Wrangler ajusta um modelo para cada atributo separadamente no fold de treinamento. Ele aplica o mínimo de pré-processamento de atributos e mede o desempenho da predição nos dados de validação.
Ele normaliza as pontuações para o intervalo [0,1]. Pontuações de predição mais altas indicam colunas mais úteis para prever o destino sozinhas. Pontuações mais baixas apontam para colunas não preditivas da coluna de destino.
É incomum que uma coluna que não seja preditiva por si só seja preditiva quando usada em conjunto com outras colunas. Você pode usar com confiança as pontuações de predição para determinar se um atributo em seu conjunto de dados é preditivo.
Uma pontuação baixa geralmente indica que o atributo é redundante. Uma pontuação de 1 indica habilidades preditivas perfeitas, o que geralmente indica vazamento do destino. O vazamento do destino geralmente ocorre quando o conjunto de dados contém uma coluna que não está disponível no momento da predição. Por exemplo, pode ser uma duplicata da coluna de destino.
Veja a seguir exemplos da tabela e do histograma que mostram o valor de predição de cada atributo.
![\[Exemplo de tabela de resumo mostrando o valor de predição de cada atributo.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/data-insights/data-insights-feature-summary-table.png)
![\[Exemplo de histograma mostrando o valor de predição de cada atributo.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/data-insights/data-insights-feature-summary-histogram.png)
## Amostras
O Data Wrangler fornece informações sobre se suas amostras são anômalas ou se há duplicatas em seu conjunto de dados.
O Data Wrangler detecta amostras anômalas usando o *algoritmo de floresta de isolamento*. A floresta de isolamento associa uma pontuação de anomalias a cada amostra (linha) do conjunto de dados. Pontuações de anomalias baixas indicam amostras anômalas. Pontuações altas estão associadas a amostras não anômalas. Amostras com pontuação de anomalias negativas geralmente são consideradas anômalas, e amostras com pontuação de anomalias positivas são consideradas não anômalas.
Ao analisar uma amostra que pode ser anômala, recomendamos que você preste atenção aos valores incomuns. Por exemplo, você pode ter valores anômalos resultantes de erros na coleta e no processamento dos dados. Recomendamos usar o conhecimento do domínio e a lógica de negócios ao examinar amostras anômalas.
O Data Wrangler detecta linhas duplicadas e calcula a proporção de linhas duplicadas em seus dados. Algumas fontes de dados podem incluir duplicatas válidas. Outras fontes de dados podem ter duplicatas que apontam para problemas na coleta de dados. Amostras duplicadas resultantes de uma coleta de dados incorreta podem interferir nos processos de machine learning que dependem da divisão dos dados em folds de treinamento e validação independentes.
A seguir estão os elementos do relatório de insights que podem ser impactados por amostras duplicadas:
+ Modelo rápido
+ Estimativa do poder de predição
+ Ajuste automático de hiperparâmetros
Você pode remover amostras duplicadas do conjunto de dados usando a transformação **Descartar duplicata** em **Gerenciar linhas.** O Data Wrangler mostra as linhas duplicadas com mais frequência.
## Definições
Estas são as definições dos termos técnicos usados no relatório de insights de dados.
------
#### [ Feature types ]
A seguir estão as definições para cada um dos tipos de atributos:
+ **Numérico**: Os valores numéricos podem ser flutuantes ou inteiros, como idade ou renda. Os modelos de machine learning pressupõem que os valores numéricos são ordenados e uma distância é definida sobre eles. Por exemplo, 3 está mais próximo de 4 do que de 10 e 3 < 4 < 10.
+ Categórico: As entradas da coluna pertencem a um conjunto de valores exclusivos, que geralmente é muito menor do que o número de entradas na coluna. Por exemplo, uma coluna de comprimento 100 pode conter os valores exclusivos `Dog`, `Cat` e `Mouse`. Os valores poderiam ser numéricos, de texto ou uma combinação de ambos. `Horse`, `House`, `8`, `Love` e `3.1` seriam todos valores válidos e poderiam ser encontrados na mesma coluna categórica. O modelo de machine learning não pressupõe ordem ou distância nos valores dos atributos categóricos, ao contrário dos atributos numéricos, mesmo quando todos os valores são números.
+ **Binário**: Os atributos binários são um tipo especial de atributo categórico no qual a cardinalidade do conjunto de valores exclusivos é 2.
+ **Texto**: Uma coluna de texto contém muitos valores exclusivos não numéricos. Em casos extremos, todos os elementos da coluna são exclusivos. Em um caso extremo, não há duas entradas iguais.
+ **Datetime**: Uma coluna de datetime contém informações sobre a data ou a hora. Ela pode ter informações de data e hora.
------
#### [ Feature statistics ]
A seguir estão as definições para cada uma das estatísticas dos atributos:
+ **Poder de predição**: O poder de predição mede o quão útil a coluna na predição do destino.
+ **Valores atípicos** (em colunas numéricas): O Data Wrangler detecta valores atípicos usando duas estatísticas que são robustas aos valores atípicos: mediana e desvio padrão robusto (RSTD). O RSTD é derivado recortando os valores dos atributos no intervalo [5 percentil, 95 percentil] e calculando o desvio padrão do vetor recortado. Todos os valores maiores que a mediana \$1 5 \$1 RSTD ou menores que a mediana - 5 \$1 RSTD são considerados atípicos.
+ **Distorção** (em colunas numéricas): A distorção mede a simetria da distribuição e é definida como o terceiro momento da distribuição dividido pela terceira potência do desvio padrão. A assimetria da distribuição normal ou de qualquer outra distribuição simétrica é zero. Valores positivos implicam que a cauda direita da distribuição é maior que a cauda esquerda. Valores positivos implicam que a cauda direita da distribuição é maior que a cauda direita. Como regra geral, uma distribuição é considerada distorcida quando o valor absoluto da distorção é maior que 3.
+ **Curtose** (em colunas numéricas): A curtose de Pearson mede o peso da cauda da distribuição. Ela é definida como o quarto momento da distribuição dividido pelo quadrado do segundo momento. A curtose da distribuição normal é 3. Valores de curtose menores que 3 implicam que a distribuição está concentrada em torno da média e as caudas são mais claras do que as caudas da distribuição normal. Valores de curtose maiores que 3 implicam caudas mais pesadas ou valores atípicos.
+ **Valores ausentes**: Objetos semelhantes a Nulo, strings vazias e compostas somente por espaços em branco são considerados ausentes.
+ **Valores válidos para atributos numéricos ou destino de regressão**: Todos os valores que você pode converter em flutuantes finitos são válidos. Valores ausentes não são válidos.
+ **Valores válidos para atributos categóricos, binários ou de texto, ou para destino de classificação**: Todos os valores que não são ausentes são válidos.
+ **Atributos de datetime**: Todos os valores que você pode converter em um objeto de datetime são válidos. Valores ausentes não são válidos.
+ **Valores inválidos**: Valores que são ausentes ou que você não pode converter corretamente. Por exemplo, em uma coluna numérica, você não pode converter a string `"six"` ou um valor nulo.
------
#### [ Quick model metrics for regression ]
A seguir estão as definições para as métricas de modelo rápido:
+ R2 ou coeficiente de determinação: R2 é a proporção da variação no destino prevista pelo modelo. R2 está no intervalo de [-infty, 1]. 1 é a pontuação do modelo que prevê o destino perfeitamente, e 0 é a pontuação do modelo trivial que sempre prevê a média de destino.
+ MSE ou erro quadrático médio: MSE está no intervalo [0, infty]. 0 é a pontuação do modelo que prevê o destino perfeitamente.
+ MAE ou erro absoluto médio: MAE está no intervalo [0, infty] em que 0 é a pontuação do modelo que prevê o destino perfeitamente.
+ RMSE ou raiz do erro quadrático médio: RMSE está no intervalo [0, infty]. em que 0 é a pontuação do modelo que prevê o destino perfeitamente.
+ Erro máximo: O valor absoluto máximo do erro no conjunto de dados. O erro máximo está no intervalo [0, infty]. 0 é a pontuação do modelo que prevê o destino perfeitamente.
+ Erro absoluto médio: O erro absoluto médio está no intervalo [0, infty]. 0 é a pontuação do modelo que prevê o destino perfeitamente.
------
#### [ Quick model metrics for classification ]
A seguir estão as definições para as métricas de modelo rápido:
+ **Precisão**: Precisão é a proporção de amostras que são previstas com precisão. A precisão está no intervalo [0, 1]. 0 é a pontuação do modelo que prevê todas as amostras incorretamente, e 1 é a pontuação do modelo perfeito.
+ **Precisão balanceada**: A precisão balanceada é a proporção de amostras que são previstas com precisão quando os pesos da classe são ajustados para equilibrar os dados. Todas as classes têm a mesma importância, independentemente da frequência. A precisão balanceada está no intervalo [0, 1]. 0 é a pontuação do modelo que prevê todas as amostras incorretamente, e 1 é a pontuação do modelo perfeito.
+ **AUC (classificação binária)**: Essa é a área sob a curva característica de operação do receptor. AUC está no intervalo [0, 1] em que um modelo aleatório retorna uma pontuação de 0,5, e o modelo perfeito retorna uma pontuação de 1.
+ **AUC (OVR)**: Para classificação multiclasse, esta é a área sob a curva característica de operação do receptor calculada separadamente para cada rótulo usando um versus rest. O Data Wrangler relata a média das áreas. AUC está no intervalo [0, 1] em que um modelo aleatório retorna uma pontuação de 0,5, e o modelo perfeito retorna uma pontuação de 1.
+ **Precisão**: A precisão é definida para uma classe específica. Precisão é a fração de positivos verdadeiros de todas as instâncias que o modelo classificou como essa classe. A precisão está no intervalo [0, 1]. 1 é a pontuação do modelo que não tem falsos-positivos para a classe. Para classificação binária, o Data Wrangler relata a precisão da classe positiva.
+ **Recall**: O recall é definido para uma classe específica. Recall é a fração das instâncias de classe relevantes que são recuperadas com sucesso. Recall está no intervalo [0, 1]. 1 é a pontuação do modelo que classifica todas as instâncias da classe corretamente. Para classificação binária, o Data Wrangler relata o recall da classe positiva.
+ **F1**: F1 é definido para uma classe específica. Ele é a média harmônica da precisão e do recall. F1 está no intervalo [0, 1]. 1 é a pontuação do modelo perfeito. Para classificação binária, o Data Wrangler relata o F1 da classe com valores positivos.
------
#### [ Textual patterns ]
**Padrões** descrevem o formato textual de uma string usando um formato fácil de ler. Estes são exemplos de padrões textuais:
+ “\$1digits:4-7\$1” descreve uma sequência de dígitos com um comprimento entre 4 e 7.
+ “\$1alnum:5\$1” descreve uma string alfanumérica com um comprimento de exatamente 5.
O Data Wrangler infere os padrões examinando amostras de strings não vazias de seus dados. Ele pode descrever muitos dos padrões comumente usados. A **confiança** expressa como uma porcentagem indica qual é a estimativa da correspondência dos dados ao padrão. Usando o padrão textual, é possível ver quais linhas de seus dados precisam ser corrigidas ou descartadas.
A seguir, descrevemos os padrões que o Data Wrangler pode reconhecer:
| Padrão | Formato textual |
| --- | --- |
| \$1alnum\$1 | Strings alfanuméricas |
| \$1any\$1 | Qualquer string de caracteres de palavras |
| \$1digits\$1 | Uma sequência de dígitos |
| \$1lower\$1 | Uma palavra minúscula |
| \$1mixed\$1 | Uma palavra com maiúsculas e minúsculas |
| \$1name\$1 | Uma palavra que começa com uma letra maiúscula |
| \$1upper\$1 | Uma palavra maiúscula |
| \$1whitespace\$1 | Caracteres de espaço em branco |
Um caractere de palavra é um sublinhado ou um caractere que pode aparecer em uma palavra em qualquer idioma. Por exemplo, as strings 'Hello\$1word' e 'écoute' ambas consistem em caracteres de palavras. “H” e “é” são exemplos de caracteres de palavras.
------
# Treine modelos automaticamente em seu fluxo de dados
Você pode usar o Amazon SageMaker Autopilot para treinar, ajustar e implantar modelos automaticamente nos dados que você transformou em seu fluxo de dados. O Amazon SageMaker Autopilot pode usar vários algoritmos e usar o que funciona melhor com seus dados. Para obter mais informações sobre o Amazon SageMaker Autopilot, consulte[SageMaker Piloto automático](autopilot-automate-model-development.md).
Quando você treina e ajusta um modelo, o Data Wrangler exporta seus dados para um local do Amazon S3 onde o SageMaker Amazon Autopilot pode acessá-los.
Você pode preparar e implantar um modelo escolhendo um nó no fluxo do Data Wrangler e escolhendo **Exportar e Treinar** na visualização prévia dos dados. Você pode usar esse método para visualizar seu conjunto de dados antes de escolher treinar um modelo nele.
Você também pode treinar e implantar um modelo diretamente do seu fluxo de dados.
O procedimento a seguir prepara e implanta um modelo a partir do fluxo de dados. Para fluxos do Data Wrangler com transformações de várias linhas, você não pode usar as transformações do fluxo do Data Wrangler ao implantar o modelo. É possível usar o procedimento a seguir para processar dados antes de usá-los para realizar inferências.
Para treinar e implantar um modelo diretamente do seu fluxo de dados, faça o seguinte:
1. Escolha o **\$1** ao lado do nó que contém os dados de treinamento.
1. Escolha o **modelo do treinamento**.
1. (Opcional) Especifique uma AWS KMS chave ou ID. Para obter mais informações sobre como criar e controlar chaves criptográficas para proteger seus dados, consulte [AWS Key Management Service](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html).
1. Escolha **Exportar e treinar**.
1. **Depois que o Amazon SageMaker Autopilot treinar o modelo nos dados que o Data Wrangler exportou, especifique um nome para o nome do experimento.**
1. Em **Dados de entrada**, escolha **Visualizar** para verificar se o Data Wrangler exportou corretamente seus dados para o Amazon Autopilot. SageMaker
1. Em **Destino**, escolha a coluna de destino.
1. (Opcional) Para a **localização do S3** em **Dados de saída**, especifique uma localização do Amazon S3 diferente da localização padrão.
1. Escolha **Avançar: método de treinamento**.
1. Escolha um método de treinamento. Para obter mais informações, consulte [Modos de treinamento](autopilot-model-support-validation.md#autopilot-training-mode).
1. (Opcional) Em **endpoint de implantação automática**, especifique um nome para o endpoint.
1. Para a **Opção Implantação**, escolha um método de implantação. Você pode optar por implantar com ou sem as transformações que você fez em seus dados.
**Importante**
Você não pode implantar um modelo Amazon SageMaker Autopilot com as transformações que você fez em seu fluxo do Data Wrangler. Para obter mais informações sobre transformações, consulte [Exportar para um endpoint de inferência](data-wrangler-data-export.md#data-wrangler-data-export-inference).
1. Selecione **Próximo: pré-visualizar e criar**.
1. Selecione **Create experiment (Criar experimento)**.
Para obter mais informações sobre treinamento e implantação de modelo, consulte [Crie trabalhos de regressão ou classificação para dados tabulares com a API do AutoML](autopilot-automate-model-development-create-experiment.md). O Autopilot mostra análises sobre o melhor desempenho do modelo. Para obter mais informações sobre desempenho, consulte [Visualizar um relatório de desempenho do modelo do Autopilot](autopilot-model-insights.md).
# Transformar dados
O Amazon SageMaker Data Wrangler fornece várias transformações de dados de ML para agilizar a limpeza, a transformação e a caracterização de seus dados. Quando você adiciona uma transformação, ela adiciona uma etapa ao fluxo de dados. Cada transformação que você adiciona modifica seu conjunto de dados e gera um novo dataframe. Todas as transformações subsequentes se aplicam ao dataframe resultante.
O Data Wrangler inclui transformações embutidas, que você pode usar para transformar colunas sem a necessidade de código. Você também pode adicionar transformações personalizadas usando PySpark Python (função definida pelo usuário), pandas e SQL. PySpark Algumas transformações operam no local, enquanto outras criam uma nova coluna de saída no seu conjunto de dados.
Você pode aplicar transformações em várias colunas ao mesmo tempo. Por exemplo, você pode excluir várias colunas em uma única etapa.
Você pode aplicar o **processo numérico** e **lidar com as transformações ausentes** somente em uma única coluna.
Use esta página para saber mais sobre essas transformações integradas e personalizadas.
## Interface de usuário da transformação
A maioria das transformações integradas está localizada na guia **Preparar** interface do usuário do Data Wrangler. Você pode acessar as transformações de união e concatenação através da visualização do fluxo de dados. Use a tabela a seguir para ter uma prévia dessas duas visualizações.
------
#### [ Transform ]
Você pode adicionar uma transformação a qualquer etapa do seu fluxo de dados. Use o procedimento a seguir para adicionar uma transformação ao fluxo de dados.
Para adicionar uma etapa ao fluxo de dados, faça o seguinte:
1. Escolha o ícone **\$1** ao lado da etapa no fluxo de dados.
1. Escolha **Adicionar transformação**.
1. Escolha **Adicionar etapa**.
![\[\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/data-wrangler-add-step.png)
1. Escolha uma transformação.
1. (Opcional) Você pode pesquisar a transformação que deseja usar. O Data Wrangler destaca a consulta nos resultados.
![\[\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/data-wrangler-search.png)
------
#### [ Join View ]
Para associar dois conjuntos de dados, selecione o primeiro conjunto de dados em seu fluxo de dados e escolha **Unir**. Ao escolher **Unir**, você verá resultados semelhantes aos mostrados na imagem a seguir. Seus conjuntos de dados esquerdo e direito são exibidos no painel esquerdo. O painel principal exibe o fluxo de seus dados, com o conjunto de dados recém-unido adicionado.
![\[O fluxo do conjunto de dados unido na seção de fluxo de dados do console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/join-1.png)
Ao escolher **Unir** para configurar sua associação, você verá resultados semelhantes aos mostrados na imagem a seguir. Sua configuração de junção é exibida no painel esquerdo. Você pode usar esse painel para escolher o nome do conjunto de dados unido, o tipo de junção e as colunas a serem unidas. O painel principal exibe três tabelas. As duas tabelas superiores exibem os conjuntos de dados esquerdo e direito à esquerda e à direita, respectivamente. Nessa tabela, você pode visualizar o conjunto de dados associado.
![\[As tabelas de conjuntos de dados unidas na seção de fluxo de dados do console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/join-2.png)
Para saber mais, consulte [Unir conjuntos de dados](#data-wrangler-transform-join).
------
#### [ Concatenate View ]
Para concatenar dois conjuntos de dados, você seleciona o primeiro conjunto de dados em seu fluxo de dados e escolhe a opção **Concatenar**. Ao escolher **Concatenar**, você verá resultados semelhantes aos mostrados na imagem a seguir. Seus conjuntos de dados esquerdo e direito são exibidos no painel esquerdo. O painel principal exibe o fluxo dos seus dados, com o conjunto de dados recém-concatenado adicionado.
![\[Exemplo de fluxo de conjunto de dados concatenado na seção de fluxo de dados no console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/concat-1.png)
Quando você escolhe **Configurar** para ajustar a sua concatenação, você verá resultados semelhantes aos mostrados na imagem a seguir. Sua configuração de concatenação é exibida no painel esquerdo. Você pode usar esse painel para escolher o nome do conjunto de dados concatenado e optar por remover duplicatas após a concatenação e adicionar colunas para indicar o dataframe de origem. O painel principal exibe três tabelas. As duas tabelas superiores exibem os conjuntos de dados esquerdo e direito à esquerda e à direita, respectivamente. Abaixo desta tabela, você pode visualizar uma prévia do conjunto de dados concatenado.
![\[Exemplos de tabelas de conjuntos de dados concatenados na seção de fluxo de dados no console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/concat-2.png)
Para saber mais, consulte [Concatenar conjuntos de dados](#data-wrangler-transform-concatenate).
------
## Unir conjuntos de dados
Você uni dataframes diretamente em seu fluxo de dados. Quando você associa dois conjuntos de dados, o conjunto resultante aparece no seu fluxo. Os seguintes tipos de união são compatíveis com o Data Wrangler:
+ **Externo esquerdo** - Inclua todas as linhas da tabela esquerda. Se o valor para a coluna na qual a associação foi feita em uma linha da tabela da esquerda não corresponder a nenhum valor nas linhas da tabela da direita, essa linha conterá valores nulos para todas as colunas da tabela da direita na tabela resultante.
+ **Anti esquerdo**: Inclui linhas da tabela à esquerda que não contêm valores na tabela à direita para a coluna unida.
+ **Semi esquerda**: Inclui uma única linha da tabela à esquerda para todas as linhas idênticas que atendem aos critérios na instrução de união. Isso exclui linhas duplicadas da tabela à esquerda que correspondam aos critérios da união.
+ **Externo direito**: Inclua todas as linhas da tabela à direita. Se o valor da coluna unida em uma linha direita da tabela não corresponder a nenhum valor da linha esquerda da tabela, essa linha conterá valores nulos para todas as colunas da tabela esquerda na tabela unida.
+ **Interno** - Inclua linhas das tabelas esquerda e direita que contêm valores correspondentes na coluna unida.
+ **Exterior completo**: Inclua todas as linhas das tabelas esquerda e direita. Se o valor da linha para a coluna de união em qualquer uma das tabelas não coincidir, linhas separadas são criadas na tabela resultante da união. Se uma linha não tiver um valor para uma coluna na tabela unida, será inserido um valor nulo para essa coluna.
+ **Produto Cartesiano** - Inclui as linhas que combinam cada linha da primeira tabela com cada linha da segunda tabela. Esse é um [produto cartesiano](https://en.wikipedia.org/wiki/Cartesian_product) de linhas de tabelas na união. O resultado desse produto é o tamanho da tabela da esquerda multiplicado pelo tamanho da tabela da direita. Portanto, recomendamos cautela ao usar essa união entre conjuntos de dados muito grandes.
Use o procedimento a seguir para unir dois dataframes.
1. Selecione **\$1** ao lado do dataframe esquerdo que você deseja unir. O primeiro dataframe que você seleciona é sempre a tabela à esquerda em sua união.
1. Selecionar **Unir**.
1. Selecione o dataframe correto. O segundo dataframe que você seleciona é sempre a tabela à direita em sua união.
1. Escolha **Configurar** para configurar sua união.
1. Dê um nome ao conjunto de dados unido usando o campo **Nome**.
1. Selecione um **Unir tipo**.
1. Selecione uma coluna das tabelas esquerda e direita para unir.
1. Escolha **Aplicar** para visualizar o conjunto de dados unido à direita.
1. Para adicionar a tabela unida ao seu fluxo de dados, escolha **Adicionar**.
## Concatenar conjuntos de dados
**Concatenar dois conjuntos de dados:**
1. Selecione **\$1** ao lado do dataframe esquerdo que você deseja unir. O primeiro dataframe que você seleciona é sempre a tabela à esquerda em sua união.
1. Escolha **Concatenar**.
1. Selecione o dataframe correto. O segundo dataframe que você seleciona é sempre a tabela à direita em sua união.
1. Escolha **Configurar** para configurar sua concatenação.
1. Dê um nome ao conjunto de dados unido usando o campo **Nome**.
1. (Opcional) Marque a caixa de seleção ao lado de **Remover duplicatas após a concatenação** para remover colunas duplicadas.
1. (Opcional) Marque a caixa de seleção ao lado de **Adicionar coluna para indicar o dataframe de origem** se, para cada coluna no novo conjunto de dados, você quiser adicionar um indicador da origem da coluna.
1. Escolha **Aplicar** para visualizar o novo conjunto de dados.
1. Escolha **Adicionar** para adicionar um novo conjunto de dados ao seu fluxo de dados.
## Dados da balança
Você pode equilibrar os dados dos conjuntos de dados com uma categoria sub-representada. O balanceamento de um conjunto de dados pode ajudar você a criar modelos melhores para classificação binária.
**nota**
Você não pode balancear conjuntos de dados contendo vetores de coluna.
Você pode usar a operação **Balancear dados** para equilibrar seus dados usando um dos seguintes operadores:
+ *Sobreamostragem aleatória*: Duplica aleatoriamente amostras na categoria minoritária. Por exemplo, se você está tentando detectar fraudes, talvez só tenha casos de fraude em 10% dos seus dados. Para uma proporção igual de casos fraudulentos e não fraudulentos, esse operador duplica aleatoriamente os casos de fraude no conjunto de dados 8 vezes.
+ *Subamostragem aleatória*: Aproximadamente equivalente à sobreamostragem aleatória. Remove aleatoriamente amostras da categoria super-representada para obter a proporção de amostras desejada.
+ *Técnica de Oversampling Sintético de Minorias (SMOTE)*: Usa amostras da categoria sub-representada para interpolar novas amostras sintéticas de minorias. Para obter mais informações sobre o SMOTE, consulte a descrição a seguir.
Você pode usar todas as transformações para conjuntos de dados contendo atributos numéricos e não numéricos. O SMOTE interpola valores usando amostras vizinhas. O Data Wrangler utiliza a distância R-quadrado para determinar o entorno no qual interpolar as amostras adicionais. O Data Wrangler usa somente atributos numéricos para calcular as distâncias entre amostras no grupo sub-representado.
Para dois exemplos reais no grupo sub-representado, o Data Wrangler interpola os atributos numéricos usando uma média ponderada. Ele atribui pesos aleatoriamente a essas amostras na faixa de [0, 1]. Para atributos numéricos, o Data Wrangler interpola amostras usando uma média ponderada das amostras. Para as amostras A e B, o Data Wrangler pode atribuir aleatoriamente um peso de 0,7 a A e 0,3 a B. A amostra interpolada tem um valor de 0,7A \$1 0,3B.
O Data Wrangler interpola atributos não numéricos copiando de qualquer uma das amostras reais interpoladas. Ele copia as amostras com uma probabilidade que é atribuída aleatoriamente a cada amostra. Para as amostras A e B, ele pode atribuir probabilidades de 0,8 a A e 0,2 a B. Para as probabilidades atribuídas, ele copia A 80% das vezes.
## Transformações personalizadas
O grupo **Transformações personalizadas** permite que você use Python (função definida pelo usuário) PySpark, pandas PySpark ou (SQL) para definir transformações personalizadas. Para todas as três opções, você usa a variável `df` para acessar o dataframe ao qual deseja aplicar a transformação. Para aplicar seu código personalizado ao seu dataframe, atribua ao dataframe as transformações que você fez na variável `df`. Se você não estiver usando Python (função definida pelo usuário), você não precisará incluir uma instrução de retorno. Escolha **Visualizar** para visualizar o resultado da transformação personalizada. Escolha **Adicionar** para adicionar a transformação personalizada à sua lista de **etapas anteriores**.
Você pode importar as bibliotecas mais conhecidas com uma `import` instrução no bloco de código de transformação personalizado, como a seguinte:
+ NumPy versão 1.19.0
+ scikit-learn versão 0.23.2
+ SciPy versão 1.5.4
+ pandas versão 1.0.3
+ PySpark versão 3.0.0
**Importante**
A opção **Personalizar transformação** não é compatível com colunas com espaços ou caracteres especiais no nome. Recomendamos que você especifique nomes de colunas que tenham somente caracteres alfanuméricos e sublinhados. Você pode usar a transformação **Renomear coluna** no grupo **Gerenciar transformação de colunas** para remover espaços do nome de uma coluna. Você também pode adicionar uma **transformação personalizada** em **Python (Pandas)** semelhante à seguinte para remover espaços de várias colunas em uma única etapa: Este exemplo altera as colunas nomeadas `A column` e `B column` para `A_column` e `B_column` respectivamente.
```
df.rename(columns={"A column": "A_column", "B column": "B_column"})
```
Se você incluir instruções de impressão no bloco de código, o resultado será exibido quando você selecionar **Visualizar**. Você pode redimensionar o painel do transformador de código personalizado. O redimensionamento do painel fornece mais espaço para escrever código. A seguinte imagem mostra o redimensionamento do painel:
![\[Para a função Python, substitua os comentários em PD.Series pelo seu código.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/resizing-panel.gif)
As seções a seguir fornecem contexto adicional e exemplos para escrever código de transformação personalizado.
**Python (função definida pelo usuário)**
A função Python oferece a capacidade de escrever transformações personalizadas sem precisar conhecer o Apache Spark ou os pandas. O Data Wrangler é otimizado para executar seu código personalizado rapidamente. Você obtém desempenho semelhante usando código Python personalizado e um plug-in Apache Spark.
Para usar o bloco de código Python (função definida pelo usuário), você especifica o seguinte:
+ **Coluna de entrada**: A coluna de entrada na qual você está aplicando a transformação.
+ **Modo**: O modo de script, pandas ou Python.
+ **Tipo de retorno**: O tipo de dados do valor que você está retornando.
Usar o modo pandas oferece melhor desempenho. O modo Python facilita a escrita de transformações ao permitir o uso de funções puramente em Python.
O vídeo a seguir mostra um exemplo de como usar código personalizado para criar uma transformação. Ele usa o [conjunto de dados do Titanic](https://s3.us-west-2.amazonaws.com/amazon-sagemaker-data-wrangler-documentation-artifacts/walkthrough_titanic.csv) para criar uma coluna com a saudação da pessoa.
![\[Para a função Python, substitua os comentários em PD.Series pelo seu código.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/python-function-transform-titanic-720.gif)
**PySpark**
O exemplo a seguir extrai data e hora de um timestamp.
```
from pyspark.sql.functions import from_unixtime, to_date, date_format
df = df.withColumn('DATE_TIME', from_unixtime('TIMESTAMP'))
df = df.withColumn( 'EVENT_DATE', to_date('DATE_TIME')).withColumn(
'EVENT_TIME', date_format('DATE_TIME', 'HH:mm:ss'))
```
**pandas**
O exemplo a seguir fornece uma visão geral do dataframe ao qual você está adicionando transformações.
```
df.info()
```
**PySpark (SQL)**
O seguinte exemplo cria um novo dataframe com quatro colunas: *nome*, *tarifa*, *classe*, *sobreviveu*.
```
SELECT name, fare, pclass, survived FROM df
```
Se você não sabe como usar PySpark, pode usar trechos de código personalizados para ajudar você a começar.
O Data Wrangler tem uma coleção que pode ser pesquisada de trechos de código. Você pode usar trechos de código para realizar tarefas como descartar colunas, agrupar por colunas ou modelar.
Para usar um trecho de código, escolha **Pesquisar trechos de exemplo** e especifique uma consulta na barra de pesquisa. O texto especificado na consulta não precisa corresponder exatamente ao nome do trecho de código.
O exemplo a seguir mostra um trecho de código Excluir **linhas duplicadas** que pode excluir linhas com dados semelhantes no seu conjunto de dados. Você pode encontrar o trecho de código pesquisando uma das seguintes opções:
+ Duplica
+ Idêntico
+ Remover
O trecho a seguir tem comentários para ajudar você a entender as alterações que você precisa fazer. Para a maioria dos trechos, você deve especificar os nomes das colunas do seu conjunto de dados no código.
```
# Specify the subset of columns
# all rows having identical values in these columns will be dropped
subset = ["col1", "col2", "col3"]
df = df.dropDuplicates(subset)
# to drop the full-duplicate rows run
# df = df.dropDuplicates()
```
Para usar um trecho, copie e cole seu conteúdo no campo **Transformação personalizada**. Você pode copiar e colar vários trechos de código no campo de transformação personalizado.
## Personalizar fórmula
Use a opção **Personalizar fórmula** para definir uma nova coluna usando uma expressão do Spark SQL para consultar dados no dataframe atual. A consulta deve usar as convenções das expressões SQL do Spark.
**Importante**
A opção **Personalizar transformação** não é compatível com colunas com espaços ou caracteres especiais no nome. Recomendamos que você especifique nomes de colunas que tenham somente caracteres alfanuméricos e sublinhados. Você pode usar a transformação **Renomear coluna** no grupo **Gerenciar transformação de colunas** para remover espaços do nome de uma coluna. Você também pode adicionar uma **transformação personalizada** em **Python (Pandas)** semelhante à seguinte para remover espaços de várias colunas em uma única etapa: Este exemplo altera as colunas nomeadas `A column` e `B column` para `A_column` e `B_column` respectivamente.
```
df.rename(columns={"A column": "A_column", "B column": "B_column"})
```
Você pode usar essa transformação para realizar operações em colunas, referenciando as colunas pelo nome. Por exemplo, supondo que o dataframe atual contenha colunas chamadas *col\$1a* e *col\$1b*, você pode usar a operação a seguir para produzir uma **coluna de saída** que seja o produto dessas duas colunas com o código a seguir:
```
col_a * col_b
```
Outras operações comuns incluem as seguintes, supondo que um dataframe contenha `col_a` colunas: `col_b`
+ Concatene duas colunas: `concat(col_a, col_b)`
+ Adicione duas colunas: `col_a + col_b`
+ Subtraia duas colunas: `col_a - col_b`
+ Divida duas colunas: `col_a / col_b`
+ Pegue o valor absoluto de uma coluna: `abs(col_a)`
Para obter mais informações, consulte a [documentação do Spark](http://spark.apache.org/docs/latest/api/python) sobre a seleção de dados.
## Reduza a dimensionalidade em um conjunto de dados
Reduza a dimensionalidade em seus dados usando a Análise de Componentes Principais (PCA). A dimensionalidade do seu conjunto de dados corresponde ao número de atributos. Ao usar a redução de dimensionalidade no Data Wrangler, você obtém um novo conjunto de atributos chamados componentes. Cada componente é responsável por alguma variabilidade nos dados.
O primeiro componente é responsável pela maior quantidade de variação nos dados. O segundo componente é responsável pela segunda maior variação nos dados e assim por diante.
Você pode usar a redução de dimensionalidade para diminuir o tamanho dos conjuntos de dados usados para treinar modelos. Em vez de usar os atributos do seu conjunto de dados, você pode usar os componentes principais.
Para realizar o PCA, o Data Wrangler cria eixos para seus dados. Um eixo é uma combinação afim de colunas no seu conjunto de dados. O primeiro componente principal é o valor no eixo que tem a maior quantidade de variância. O segundo componente principal é o valor no eixo que possui a segunda maior quantidade de variação. O enésimo componente principal é o valor no eixo que possui a enésima maior quantidade de variação.
Você pode configurar o número de componentes principais que o Data Wrangler retorna. Você pode especificar diretamente o número de componentes principais ou especificar a porcentagem do limite de variação. Cada componente principal explica uma quantidade de variação nos dados. Por exemplo, você pode ter um componente principal com um valor de 0,5. O componente explicaria 50% da variação nos dados. Quando você especifica uma porcentagem de limite de variação, o Data Wrangler retorna o menor número de componentes que atendem à porcentagem especificada.
A seguir estão exemplos de componentes principais com a quantidade de variação que eles explicam nos dados.
+ Componente 1: 0,5
+ Componente 2: 0,45
+ Componente 3: 0,05
Se você especificar uma porcentagem de limite de variação de `94` ou `95`, o Data Wrangler retornará o Componente 1 e o Componente 2. Se você especificar uma porcentagem de limite de variação de `96`, o Data Wrangler retornará todos os três componentes principais.
É possível usar o procedimento a seguir para executar o PCA em seu conjunto de dados.
Para executar o PCA em seu conjunto de dados, faça o seguinte:
1. Abra seu fluxo de dados do Data Wrangler.
1. Escolha o **\$1** e selecione **Adicionar transformação**.
1. Escolha **Adicionar etapa**.
1. Escolha **Redução de Dimensionalidade.**
1. Em **Colunas de entrada**, escolha os atributos que você está reduzindo aos componentes principais.
1. (Opcional) Em **Número de componentes principais**, escolha o número de componentes principais que o Data Wrangler retorna em seu conjunto de dados. Se especificar um valor para o campo, você não poderá especificar um valor para a porcentagem do **limite de variação**.
1. (Opcional) Para **Porcentagem do limite de variação**, especifique a porcentagem de variação nos dados que você deseja explicar pelos componentes principais. O Data Wrangler usará o valor padrão de `95` se você não especificar um valor para o limite de variância. Você não pode especificar uma porcentagem de limite de variação se tiver especificado um valor para **Número de componentes principais**.
1. (Opcional) Desmarque a opção **Centralizar** para não usar a média das colunas como centro dos dados. Por padrão, o Data Wrangler centraliza os dados com a média antes do escalonamento.
1. (Opcional) Desmarque a opção **Escalar** para não dimensionar os dados com o desvio padrão da unidade.
1. (Opcional) Escolha **Colunas** para produzir os componentes em colunas separadas. Escolha **Vetor** para gerar os componentes como um único vetor.
1. (Opcional) Em **Coluna de saída**, especifique um nome para uma coluna de saída. Se você estiver enviando os componentes em colunas separadas, o nome especificado será um prefixo. Se você estiver enviando os componentes para um vetor, o nome especificado será o nome da coluna vetorial.
1. (Opcional) Selecione **Manter colunas de entrada**. Não recomendamos selecionar essa opção se você planeja usar apenas os componentes principais para treinar seu modelo.
1. Escolha **Pré-visualizar**.
1. Escolha **Adicionar**.
## Codificar categórico
Os dados categóricos geralmente são compostos por um número finito de categorias, onde cada categoria é representada por um segmento. Por exemplo, se você tiver uma tabela de dados de clientes, uma coluna que indica o país em que a pessoa mora é categórica. As categorias seriam *Afeganistão*, *Albânia*, *Argélia* e assim por diante. Os dados categóricos podem ser *nominais* ou *ordinais*. As categorias ordinais têm uma ordem inerente e as categorias nominais não. O grau mais *alto obtido (ensino médio*, *bacharelado*, *mestrado*, etc.) é um exemplo de categorias ordinais.
A codificação de dados categóricos é o processo de criação de uma representação numérica para categorias. Por exemplo, se suas categorias são *Cachorro* e *Gato*, você pode codificar essas informações em dois vetores, `[1,0]` para representar *Cachorro* e `[0,1]` para representar *Gato*.
Ao codificar categorias ordinais, talvez seja necessário traduzir a ordem natural das categorias em sua codificação. Por exemplo, você pode representar o grau mais alto obtido com o seguinte mapa: `{"High school": 1, "Bachelors": 2, "Masters":3}`.
Use codificação categórica para codificar dados categóricos que estão no formato de segmento em matrizes de números inteiros.
Os codificadores categóricos do Data Wrangler criam codificações para todas as categorias que existem em uma coluna no momento em que a etapa é definida. Se novas categorias foram adicionadas a uma coluna quando você inicia uma tarefa do Data Wrangler para processar seu conjunto de dados no momento *t*, e essa coluna foi a entrada para uma transformação da codificação categórica do Data Wrangler no momento *t*-1, essas novas categorias serão consideradas *ausentes* na tarefa do Data Wrangler. A opção selecionada para **Estratégia de tratamento inválida** é aplicada a esses valores ausentes. Exemplos de quando isso pode ocorrer são:
+ Quando você usa um arquivo.flow para criar uma tarefa do Data Wrangler para processar um conjunto de dados que foi atualizado após a criação do fluxo de dados. Por exemplo, você pode usar um fluxo de dados para processar regularmente os dados de vendas a cada mês. Se esses dados de vendas forem atualizados semanalmente, novas categorias poderão ser introduzidas em colunas para as quais uma etapa categórica de codificação é definida.
+ Quando você seleciona **Amostragem** ao importar seu conjunto de dados, algumas categorias podem ser deixadas de fora da amostra.
Nessas situações, essas novas categorias são consideradas valores ausentes no trabalho do Data Wrangler.
Você pode escolher e configurar uma codificação *ordinal* e uma codificação *única.* Use as seguintes seções para saber mais sobre essas opções:
Ambas as transformações criam uma nova coluna chamada **Nome da coluna de saída**. Você especifica o formato de saída dessa coluna com o **estilo de saída**:
+ Selecione **Vetor** para produzir uma única coluna com um vetor esparso.
+ Selecione **Colunas** para criar uma coluna para cada categoria com uma variável indicadora para determinar se o texto na coluna original contém um valor igual a essa categoria.
### Codificação ordinal
Selecione Codificação **ordinal para codificar** categorias em um número inteiro entre 0 e o número total de categorias na coluna de **entrada** selecionada.
**Estratégia de tratamento inválida**: selecione um método para lidar com valores inválidos ou ausentes.
+ Escolha **Ignorar** se quiser omitir as linhas com valores ausentes.
+ Escolha **Manter** para reter os valores ausentes como a última categoria.
+ Escolha **Erro** se quiser que o Data Wrangler gere um erro se forem encontrados valores ausentes na **coluna de entrada**.
+ Escolha **Substituir por NaN** para substituir o ausente por NaN. Essa opção é recomendada se seu algoritmo de ML puder processar valores ausentes. Caso contrário, as três primeiras opções dessa lista podem produzir melhores resultados.
### Codificação One-Hot
Selecione **Codificação única** para **Transformar** para usar a codificação única. Configure essa transformação usando o seguinte:
+ **Eliminar a última categoria**: se `True` a última categoria não tiver um índice correspondente na codificação one-hot. Quando valores ausentes são possíveis, uma categoria ausente é sempre a última e definir isso `True` significa que um valor ausente resulta em um vetor totalmente zero.
+ **Estratégia de tratamento inválida**: selecione um método para lidar com valores inválidos ou ausentes.
+ Escolha **Ignorar** se quiser omitir as linhas com valores ausentes.
+ Escolha **Manter** para reter os valores ausentes como a última categoria.
+ Escolha **Erro** se quiser que o Data Wrangler gere um erro se forem encontrados valores ausentes na **coluna de entrada**.
+ **A entrada é codificada ordinalmente**: selecione essa opção se o vetor de entrada contiver dados codificados ordinais. Essa opção exige que os dados de entrada contenham números inteiros não negativos. Se **Verdadeiro**, a entrada *i* é codificada como um vetor com um valor diferente de zero no *local i.*
### Codificação de similaridade
Use a codificação de similaridade quando você tiver o seguinte:
+ Um grande número de variáveis categóricas
+ Dados ruidosos
O codificador de similaridade cria incorporações para colunas com dados categóricos. Uma incorporação é uma correspondência de objetos discretos, como palavras, para vetores de números reais. Codifica segmentos semelhantes em vetores contendo valores semelhantes. Por exemplo, ele cria codificações muito semelhantes para “California” e “Calfornia”.
O Data Wrangler converte cada categoria em seu conjunto de dados em um conjunto de tokens usando um tokenizador de 3 gramas. Ele converte os tokens em uma incorporação usando a codificação min-hash.
O exemplo a seguir mostra como o codificador de similaridade cria vetores a partir de segmentos.
![\[Exemplo de uso de CODIFICAR CATEGÓRICO para uma tabela no console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/destination-nodes/similarity-encode-example-screenshot-0.png)
![\[Exemplo de representação vetorial de uma variável encontrada em uma tabela no console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/destination-nodes/similarity-encode-example-screenshot-1.png)
As codificações de similaridade que o Data Wrangler cria:
+ Têm baixa dimensionalidade
+ São escaláveis para um grande número de categorias
+ São robustos e resistentes ao ruído
Pelas razões anteriores, a codificação por similaridade é mais versátil do que a codificação one-hot.
Para adicionar a transformação de codificação de similaridade ao seu conjunto de dados, use o procedimento a seguir.
Para usar a codificação de similaridade, faça o seguinte:
1. Faça login no [Amazon SageMaker AI Console](https://console.aws.amazon.com/sagemaker/).
1. Escolha **Abrir Studio Classic**.
1. Escolha **Iniciar aplicação**.
1. Escolha **Studio**.
1. Especifique seu fluxo de dados.
1. Escolha uma etapa com uma transformação.
1. Escolha **Adicionar etapa**.
1. Escolha **Codificar categórico**.
1. Especifique o seguinte:
+ **Transformação**: **Codificação por similaridade**
+ **Coluna de entrada**: A coluna que contém os dados categóricos que você está codificando.
+ **Dimensão de destino**: (Opcional) A dimensão do vetor de incorporação categórica. O valor padrão é 30. Recomendamos usar uma dimensão alvo maior se você tiver um grande conjunto de dados com muitas categorias.
+ **Estilo de saída**: Escolha **Vetor** para um único vetor com todos os valores codificados. Escolha **Coluna** para ter os valores codificados em colunas separadas.
+ **Coluna de saída**: (Opcional) O nome da coluna de saída para uma saída codificada em vetor. Para uma saída codificada em coluna, esse é o prefixo dos nomes das colunas seguido pelo número listado.
## Caracterizar texto
Use o grupo de transformação **Caracterizar texto** para inspecionar colunas digitadas por segmento e use a incorporação de texto para destacar essas colunas.
Esse grupo de atributos contém dois atributos, *estatísticas de caracteres* e *vetorização*. Use as seções a seguir para saber mais sobre essas transformações. Para ambas as opções, a **coluna de entrada** deve conter dados de texto (tipo segmento).
### Estatísticas de personagens
Use **estatísticas de caracteres** para gerar estatísticas para cada linha em uma coluna contendo dados de texto.
Essa transformação calcula as seguintes proporções e contagens para cada linha e cria uma nova coluna para relatar o resultado: A nova coluna é nomeada usando o nome da coluna de entrada como um prefixo e um sufixo específico da proporção ou contagem.
+ **Número de palavras**: o número total de palavras nessa linha. O sufixo dessa coluna de saída é`-stats_word_count`.
+ **Número de caracteres**: o número total de caracteres nessa linha. O sufixo dessa coluna de saída é`-stats_char_count`.
+ **Proporção maior**: o número de caracteres maiúsculos, de A a Z, dividido por todos os caracteres na coluna. O sufixo dessa coluna de saída é`-stats_capital_ratio`.
+ **Proporção menor**: o número de caracteres minúsculos, de a a z, dividido por todos os caracteres da coluna. O sufixo dessa coluna de saída é `-stats_lower_ratio`.
+ **Proporção de dígitos**: A proporção de dígitos em uma única linha sobre a soma dos dígitos na coluna de entrada. O sufixo dessa coluna de saída é`-stats_digit_ratio`.
+ **Proporção de caracteres especiais**: a proporção de caracteres não alfanuméricos (como \$1\$1&%:@) em relação à soma de todos os caracteres na coluna de entrada. O sufixo dessa coluna de saída é `-stats_special_ratio`.
### Vetorizar
A incorporação de texto envolve o mapeamento de palavras ou frases de um vocabulário para vetores de números reais. Use a transformação de incorporação de texto do Data Wrangler para tokenizar e vetorizar dados de texto em vetores de frequência de documento inversa de frequência de termo (TF-IDF).
Quando o TF-IDF é calculado para uma coluna de dados de texto, cada palavra de cada frase é convertida em um número real que representa sua importância semântica. Números mais altos estão associados a palavras menos frequentes, que tendem a ser mais significativas.
Quando você define uma etapa de transformação **Vetorizar**, o Data Wrangler usa os dados em seu conjunto de dados para definir o vetorizador de contagem e os métodos TF-IDF. A execução de um trabalho do Data Wrangler usa esses mesmos métodos.
Você configura essa transformação usando o seguinte:
+ **Nome da coluna de saída**: essa transformação cria uma nova coluna com a incorporação do texto. Use esse campo para especificar um nome para essa coluna de saída.
+ **Tokenizador**: um tokenizador converte a frase em uma lista de palavras ou *tokens*.
Escolha **Padrão** para usar um tokenizador que divide por espaço em branco e converte cada palavra em minúsculas. Por exemplo, `"Good dog"` é tokenizado para `["good","dog"]`.
Escolha **Personalizar** para usar um tokenizador personalizado. Se você escolher **Personalizar**, poderá usar os seguintes campos para configurar o tokenizador:
+ **Tamanho mínimo do token**: o tamanho mínimo, em caracteres, para que um token seja válido. O padrão é `1`. Por exemplo, se você especificar `3` o tamanho mínimo do token, palavras como `a, at, in` são retiradas da frase tokenizada.
+ O **regex deve ser dividido em lacunas**: Se selecionado, o **regex** divide em lacunas. Caso contrário, ele corresponderá aos tokens. O padrão é `True`.
+ **Padrão Regex**: o padrão que define o processo de tokenização. O padrão é `' \\ s+'`.
+ **Para minúsculas**: se escolhido, o Data Wrangler converte todos os caracteres em minúsculas antes da tokenização. O padrão é `True`.
Para saber mais, consulte a documentação do Spark sobre o [Tokenizer](https://spark.apache.org/docs/latest/ml-features#tokenizer).
+ **Vetorizador**: o vetorizador converte a lista de tokens em um vetor numérico esparso. Cada token corresponde a um índice no vetor e um valor diferente de zero indica a existência do token na frase de entrada. Você pode escolher entre duas opções de vetorização, *Count* e *Hashing*.
+ A **vetorização de contagem** permite personalizações que filtram tokens pouco frequentes ou muito comuns. Os **parâmetros de vetorização de contagem** incluem o seguinte:
+ **Frequência mínima do termo**: em cada linha, os termos (tokens) com menor frequência são filtrados. Se você especificar um número inteiro, este será um limite absoluto (inclusivo). Se você especificar uma fração entre 0 (inclusive) e 1, o limite será relativo à contagem total de termos. O padrão é `1`.
+ **Frequência mínima do documento**: número mínimo de linhas nas quais um termo (token) deve aparecer para ser incluído. Se você especificar um número inteiro, este será um limite absoluto (inclusivo). Se você especificar uma fração entre 0 (inclusive) e 1, o limite será relativo à contagem total de termos. O padrão é `1`.
+ **Frequência máxima de documentos**: Número máximo de documentos (linhas) nos quais um termo (token) pode aparecer incluído. Se você especificar um número inteiro, este será um limite absoluto (inclusivo). Se você especificar uma fração entre 0 (inclusive) e 1, o limite será relativo à contagem total de termos. O padrão é `0.999`.
+ **Tamanho máximo do vocabulário**: tamanho máximo do vocabulário. O vocabulário é composto por todos os termos (tokens) em todas as linhas da coluna. O padrão é `262144`.
+ **Saídas binárias**: se selecionadas, as saídas vetoriais não incluem o número de aparições de um termo em um documento, mas são um indicador binário de sua aparência. O padrão é `False`.
Para saber mais sobre essa opção, consulte a documentação do Spark em [CountVectorizer](https://spark.apache.org/docs/latest/ml-features#countvectorizer).
+ O **hashing** é computacionalmente mais rápido. Os **parâmetros de vetorização de hashing** incluem o seguinte:
+ **Número de atributos durante o hash**: um vetorizador de hash mapeia tokens para um índice vetorial de acordo com seu valor de hash. Esse atributo determina o número de valores de hash possíveis. Valores grandes resultam em menos colisões entre valores de hash, mas em um vetor de saída de maior dimensão.
Para saber mais sobre essa opção, consulte a documentação do Spark em [FeatureHasher](https://spark.apache.org/docs/latest/ml-features#featurehasher)
+ O **Apply IDF** aplica uma transformação IDF, que multiplica a frequência do termo pela frequência inversa padrão do documento usada para incorporação TF-IDF. Os **parâmetros IDF** incluem o seguinte:
+ **Frequência mínima do documento**: número mínimo de documentos (linhas) nos quais um termo (token) deve aparecer para ser incluído. Se **count\$1vectorize** for o vetorizador escolhido, recomendamos que você mantenha o valor padrão e modifique somente o campo **min\$1doc\$1freq** nos **parâmetros de vetorização de contagem.** O padrão é `5`.
+ **Formato de saída**: o formato de saída de cada linha.
+ Selecione **Vetor** para produzir uma única coluna com um vetor esparso.
+ Selecione **Nivelado** para criar uma coluna para cada categoria com uma variável indicadora para saber se o texto na coluna original contém um valor igual a essa categoria. Você só pode escolher achatado quando **Vetorizador** é definido como **vetorizador de contagem.**
## Séries temporais de transformações
No Data Wrangler, você pode transformar dados de séries temporais. Os valores em um conjunto de dados de série temporal são indexados em um horário específico. Por exemplo, um conjunto de dados que mostra o número de clientes em uma loja para cada hora do dia é um conjunto de dados de séries temporais. A tabela a seguir mostra um exemplo de um conjunto de dados de séries temporais.
Número horário de clientes em uma loja
| Número de clientes | Hora (hora) |
| --- | --- |
| 4 | 09:00 |
| 10 | 10:00 |
| 14 | 11:00 |
| 25 | 12:00 |
| 20 | 13:00 |
| 18 | 14:00 |
Para a tabela anterior, a coluna **Número de clientes** contém os dados de séries temporais. Os dados da série temporal são indexados nos dados horários na coluna **Tempo (hora)**.
Talvez seja necessário realizar uma série de transformações em seus dados para obtê-los em um formato que possa ser usado em sua análise. Use o grupo de transformação de **séries temporais** para transformar seus dados de séries temporais. Para obter mais informações sobre as transformações que você pode executar, consulte as seções a seguir.
**Topics**
+ [Agrupar por uma série temporal](#data-wrangler-group-by-time-series)
+ [Reamostragem de dados de séries temporais](#data-wrangler-resample-time-series)
+ [Lidar com dados de séries temporais ausentes](#data-wrangler-transform-handle-missing-time-series)
+ [Valide o timestamp de seus dados de séries temporais](#data-wrangler-transform-validate-timestamp)
+ [Padronizando a duração da série temporal](#data-wrangler-transform-standardize-length)
+ [Extrair atributos de seus dados de séries temporais](#data-wrangler-transform-extract-time-series-features)
+ [Use atributos atrasados de seus dados de séries temporais](#data-wrangler-transform-lag-time-series)
+ [Crie um intervalo de data e hora em sua série temporal](#data-wrangler-transform-datetime-range)
+ [Use uma janela contínua em sua série temporal](#data-wrangler-transform-rolling-window)
### Agrupar por uma série temporal
Você pode usar a operação agrupar por para agrupar dados de séries temporais para valores específicos em uma coluna.
Por exemplo, você tem a tabela a seguir que monitora o uso médio diário de eletricidade em uma residência.
Uso médio diário de eletricidade doméstica
| ID da residência | Timestamp diário | Uso de eletricidade (kWh) | Número de ocupantes da residência |
| --- | --- | --- | --- |
| household\$10 | 1/1/2020 | 30 | 2 |
| household\$10 | 1/2/2020 | 40 | 2 |
| household\$10 | 1/4/2020 | 35 | 3 |
| household\$11 | 1/2/2020 | 45 | 3 |
| household\$11 | 1/3/2020 | 55 | 4 |
Se optar por agrupar por ID, você obterá a tabela a seguir.
Uso de eletricidade agrupado por identificação residencial
| ID da residência | Série de uso de eletricidade (kWh) | Série do número de ocupantes da residência |
| --- | --- | --- |
| household\$10 | [30, 40, 35] | [2, 2, 3] |
| household\$11 | [45, 55] | [3, 4] |
Cada entrada na sequência da série temporal é ordenada pelo timestamp correspondente. O primeiro elemento da sequência corresponde ao primeiro timestamp da série. Para `household_0`, `30` é o primeiro valor da **Série de uso de eletricidade**. O valor de `30` corresponde ao primeiro timestamp de `1/1/2020`.
Você pode incluir o timestamp inicial e o timestamp final. A tabela a seguir mostra como essas informações aparecem.
Uso de eletricidade agrupado por identificação residencial
| ID da residência | Série de uso de eletricidade (kWh) | Série do número de ocupantes da residência | Start\$1time | End\$1time |
| --- | --- | --- | --- | --- |
| household\$10 | [30, 40, 35] | [2, 2, 3] | 1/1/2020 | 1/4/2020 |
| household\$11 | [45, 55] | [3, 4] | 1/2/2020 | 1/3/2020 |
Você pode usar o procedimento a seguir para agrupar por uma coluna de série temporal.
1. Abra seu fluxo de dados do Data Wrangler.
1. Se você não importou seu conjunto de dados, importe-o na guia **Importar dados**.
1. No seu fluxo de dados, em **Tipos de dados**, escolha o **\$1** e selecione **Adicionar transformação**.
1. Escolha **Adicionar etapa**.
1. Escolha **Séries temporais**.
1. Em **Transformação**, escolha **Agrupar por**.
1. Especifique uma coluna em **Agrupar por esta coluna**.
1. Em **Aplicar às colunas**, especifique um valor.
1. Escolha **Visualizar** para gerar uma visualização prévia da transformação.
1. Escolha **Adicionar** para adicionar a transformação ao fluxo de dados do Data Wrangler.
### Reamostragem de dados de séries temporais
Os dados de séries temporais geralmente têm observações que não são feitas em intervalos regulares. Por exemplo, um conjunto de dados pode ter algumas observações que são registradas de hora em hora e outras observações que são registradas a cada duas horas.
Muitas análises, como algoritmos de previsão, exigem que as observações sejam feitas em intervalos regulares. A reamostragem permite estabelecer intervalos regulares para as observações em seu conjunto de dados.
Você pode aumentar ou diminuir a resolução de uma série temporal. O downsampling (redução da taxa de amostragem) aumenta o intervalo entre as observações no conjunto de dados. Por exemplo, se você reduzir a resolução de observações feitas a cada hora ou a cada duas horas, cada observação em seu conjunto de dados será feita a cada duas horas. As observações horárias são agregadas em um único valor usando um método de agregação, como média ou mediana.
O upsampling (aumento da taxa de amostragem) reduz o intervalo entre as observações no conjunto de dados. Por exemplo, se você transformar observações feitas a cada duas horas em observações de hora em hora, poderá usar um método de interpolação para inferir observações de hora em hora daquelas que foram feitas a cada duas horas. [Para obter informações sobre métodos de interpolação, consulte pandas. DataFrame.interpolar](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.interpolate.html).
Você pode reamostrar dados numéricos e não numéricos.
Use a operação **Reamostrar** para reamostrar seus dados de séries temporais. Se você tiver várias séries temporais em seu conjunto de dados, o Data Wrangler padronizará o intervalo de tempo para cada série temporal.
A tabela a seguir mostra um exemplo de redução da amostragem de dados de séries temporais usando a média como método de agregação. Os dados são reduzidos de duas em duas horas para cada hora.
Leituras de temperatura de hora em hora durante um dia antes da redução da amostragem
| Timestamp | Temperatura (Celsius) |
| --- | --- |
| 12:00 | 30 |
| 1:00 | 32 |
| 2:00 | 35 |
| 3:00 | 32 |
| 4:00 | 30 |
Leituras de temperatura reduzidas para cada duas horas
| Timestamp | Temperatura (Celsius) |
| --- | --- |
| 12:00 | 30 |
| 2:00 | 33.5 |
| 4:00 | 35 |
Você pode usar o procedimento a seguir para reamostrar dados de série temporal.
1. Abra seu fluxo de dados do Data Wrangler.
1. Se você não importou seu conjunto de dados, importe-o na guia **Importar dados**.
1. No seu fluxo de dados, em **Tipos de dados**, escolha o **\$1** e selecione **Adicionar transformação**.
1. Escolha **Adicionar etapa**.
1. Escolha **Reamostrar**.
1. Em **Timestamp**, escolha a coluna de timestamp.
1. Em **Unidade de frequência**, especifique a frequência com a qual você está reamostrando.
1. (Opcional) Especifique um valor para a **quantidade de frequência**.
1. Configure a transformação especificando os campos restantes.
1. Escolha **Visualizar** para gerar uma visualização prévia da transformação.
1. Escolha **Adicionar** para adicionar a transformação ao fluxo de dados do Data Wrangler.
### Lidar com dados de séries temporais ausentes
Se você tiver valores ausentes em seu conjunto de dados, realize um dos seguintes procedimentos:
+ Para conjuntos de dados com várias séries temporais, elimine as séries temporais com valores ausentes maiores que o limite especificado por você.
+ Impute os valores ausentes em uma série temporal usando outros valores na série temporal.
A imputação de um valor ausente envolve a substituição dos dados especificando um valor ou usando um método inferencial. A seguir estão os métodos que você pode usar para imputação:
+ Valor constante: Substitua todos os dados ausentes em seu conjunto de dados por um valor especificado por você.
+ Valor mais comum: Substitua todos os dados ausentes pelo valor que tem a maior frequência no conjunto de dados.
+ Preenchimento futuro: Use um preenchimento futuro para substituir os valores ausentes pelo valor não faltante que precede os valores ausentes. Para a sequência: [2, 4, 7, NaN, NaN, NaN, 8], todos os valores ausentes são substituídos por 7. A sequência resultante do uso de um preenchimento direto é [2, 4, 7, 7, 7, 7, 7, 8].
+ Preenchimento reverso: Use um preenchimento reverso para substituir os valores ausentes pelo valor não omisso que segue os valores ausentes. Para a sequência: [2, 4, 7, NaN, NaN, NaN, 8], todos os valores ausentes são substituídos por 8. A sequência resultante do uso de preenchimento reverso é [2, 4, 7, 8, 8, 8, 8].
+ Interpolar: Usa uma função de interpolação para imputar os valores ausentes. [Para obter mais informações sobre as funções que você pode usar para interpolação, consulte pandas. DataFrame.interpolar](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.interpolate.html).
Alguns dos métodos de imputação podem não conseguir imputar todos os valores ausentes em seu conjunto de dados. Por exemplo, um **Preenchimento direto** não pode imputar um valor ausente que aparece no início da série temporal. Você pode imputar os valores usando um preenchimento direto ou um preenchimento reverso.
Você pode imputar valores ausentes em uma célula ou em uma coluna.
O exemplo a seguir mostra como os valores são imputados dentro de uma célula.
Uso de eletricidade com valores faltantes
| ID da residência | Série de uso de eletricidade (kWh) |
| --- | --- |
| household\$10 | [30, 40, 35, NaN, NaN] |
| household\$11 | [45, NaN, 55] |
Uso de eletricidade com valores imputados usando um preenchimento direto
| ID da residência | Série de uso de eletricidade (kWh) |
| --- | --- |
| household\$10 | [30, 40, 35, 35, 35] |
| household\$11 | [45, 45, 55] |
O exemplo a seguir mostra como os valores são imputados em uma coluna.
Uso médio diário de eletricidade doméstica com valores faltantes
| ID da residência | Uso de eletricidade (kWh) |
| --- | --- |
| household\$10 | 30 |
| household\$10 | 40 |
| household\$10 | NaN |
| household\$11 | NaN |
| household\$11 | NaN |
Consumo médio diário de eletricidade doméstica com valores imputados usando um preenchimento direto
| ID da residência | Uso de eletricidade (kWh) |
| --- | --- |
| household\$10 | 30 |
| household\$10 | 40 |
| household\$10 | 40 |
| household\$11 | 40 |
| household\$11 | 40 |
Você pode usar o procedimento a seguir para processar valores ausentes.
1. Abra seu fluxo de dados do Data Wrangler.
1. Se você não importou seu conjunto de dados, importe-o na guia **Importar dados**.
1. No seu fluxo de dados, em **Tipos de dados**, escolha o **\$1** e selecione **Adicionar transformação**.
1. Escolha **Adicionar etapa**.
1. Escolha **Processar ausentes**.
1. Para o **tipo de entrada de série temporal**, escolha se você deseja processar valores ausentes dentro de uma célula ou ao longo de uma coluna.
1. Em **Imputar valores ausentes para esta coluna**, especifique a coluna que tem os valores ausentes.
1. Em **Método para imputar valores**, selecione um método.
1. Configure a transformação especificando os campos restantes.
1. Escolha **Visualizar** para gerar uma visualização prévia da transformação.
1. Se você tiver valores ausentes, poderá especificar um método para imputá-los em **Método para imputar valores**.
1. Escolha **Adicionar** para adicionar a transformação ao fluxo de dados do Data Wrangler.
### Valide o timestamp de seus dados de séries temporais
Você pode ter dados de timestamps inválidos. Você pode usar a função **Validate timestamp** para determinar se os timestamps no seu conjunto de dados são válidos. Seu timestamp pode ser inválido por um ou mais dos seguintes motivos:
+ Sua coluna de timestamp tem valores ausentes.
+ Os valores na coluna de timestamp não estão formatados corretamente.
Se você tiver timestamps inválidos em seu conjunto de dados, não poderá realizar sua análise com êxito. Você pode usar o Data Wrangler para identificar timestamps inválidos e entender onde você precisa limpar seus dados.
A validação da série temporal funciona de uma das duas maneiras:
Você pode configurar o Data Wrangler para executar uma das seguintes ações se ele encontrar valores ausentes em seu conjunto de dados:
+ Elimine as linhas que têm os valores ausentes ou inválidos.
+ Elimine as linhas que têm os valores ausentes ou inválidos.
+ Lance um erro se encontrar algum valor ausente ou inválido no seu conjunto de dados.
Você pode validar os timestamps em colunas que tenham o tipo `timestamp` ou o tipo `string`. Se a coluna tiver o tipo `string`, o Data Wrangler converterá o tipo da coluna em `timestamp` e executará a validação.
É possível usar o procedimento a seguir para validar os timestamps em seu conjunto de dados.
1. Abra seu fluxo de dados do Data Wrangler.
1. Se você não importou seu conjunto de dados, importe-o na guia **Importar dados**.
1. No seu fluxo de dados, em **Tipos de dados**, escolha o **\$1** e selecione **Adicionar transformação**.
1. Escolha **Adicionar etapa**.
1. Escolha **Validar timestamps**.
1. Na **Coluna timestamp**, escolha a coluna Timestamp.
1. Em **Política**, escolha se você deseja lidar com timestamps ausentes.
1. (Opcional) Em **Coluna de saída**, especifique um nome para a coluna de saída.
1. Se a coluna de data e hora estiver formatada para o tipo de segmento, escolha **Transmitir para data e hora**.
1. Escolha **Visualizar** para gerar uma visualização prévia da transformação.
1. Escolha **Adicionar** para adicionar a transformação ao fluxo de dados do Data Wrangler.
### Padronizando a duração da série temporal
Se você tiver dados de séries temporais armazenados como matrizes, poderá padronizar cada série temporal com o mesmo tamanho. Padronizar o tamanho da matriz de séries temporais pode facilitar a realização da análise dos dados.
Você pode padronizar suas séries temporais para transformações de dados que exigem que o tamanho dos dados seja corrigido.
Muitos algoritmos de ML exigem que você nivele seus dados de séries temporais antes de usá-los. Nivelar os dados da série temporal é separar cada valor da série temporal em sua própria coluna em um conjunto de dados. O número de colunas em um conjunto de dados não pode mudar, então os comprimentos das séries temporais precisam ser padronizados entre você e nivelar cada matriz em um conjunto de atributos.
Cada série temporal é definida com o comprimento que você especifica como um quantil ou percentil do conjunto de séries temporais. Por exemplo, você pode ter três sequências com os seguintes comprimentos:
+ 3
+ 4
+ 5
Você pode definir o comprimento de todas as sequências como o comprimento da sequência que tem o comprimento do 50º percentil.
Matrizes de séries temporais menores do que o comprimento especificado têm valores ausentes adicionados. A seguir está um exemplo de formato de padronização da série temporal para um comprimento maior: [2, 4, 5, NaN, NaN, NaN].
Você pode usar abordagens diferentes para lidar com os valores ausentes. Para obter mais informações sobre essas abordagens, consulte [Lidar com dados de séries temporais ausentes](#data-wrangler-transform-handle-missing-time-series).
As matrizes de séries temporais maiores que o comprimento especificado são truncadas.
É possível usar o procedimento a seguir para padronizar a duração da série temporal.
1. Abra seu fluxo de dados do Data Wrangler.
1. Se você não importou seu conjunto de dados, importe-o na guia **Importar dados**.
1. No seu fluxo de dados, em **Tipos de dados**, escolha o **\$1** e selecione **Adicionar transformação**.
1. Escolha **Adicionar etapa**.
1. Escolha **Padronizar comprimento.**
1. Para **Padronizar o comprimento da série temporal da coluna**, escolha uma coluna.
1. (Opcional) Em **Coluna de saída**, especifique um nome para a coluna de saída. Se você não especificar um nome, a transformação será feita no local.
1. Se a coluna de data e hora estiver formatada para o tipo de segmento, escolha **Transmitir para data e hora**.
1. Escolha **Quantil de corte** e especifique um quantil para definir o comprimento da sequência.
1. Escolha **Nivelar a saída** para gerar os valores da série temporal em colunas separadas.
1. Escolha **Visualizar** para gerar uma visualização prévia da transformação.
1. Escolha **Adicionar** para adicionar a transformação ao fluxo de dados do Data Wrangler.
### Extrair atributos de seus dados de séries temporais
Se você estiver executando uma classificação ou um algoritmo de regressão em seus dados de série temporal, recomendamos extrair atributos da série temporal antes de executar o algoritmo. A extração de atributos pode melhorar o desempenho do seu algoritmo.
Use as seguintes opções para escolher como você deseja extrair os atributos dos seus dados:
+ Use o **Subconjunto mínimo** para especificar a extração de 8 atributos que você sabe que são úteis em análises posteriores. Você pode usar um subconjunto mínimo quando precisar realizar cálculos rapidamente. Você também pode usá-lo quando seu algoritmo de ML tem um alto risco de sobreajuste e você deseja fornecer menos atributos.
+ Use o **subconjunto eficiente** para especificar a extração do maior número possível de atributos sem extrair atributos que são computacionalmente intensivos em suas análises.
+ Use **Todos os atributos** para especificar a extração de todos os atributos da série de músicas.
+ Use o **Subconjunto manual** para escolher uma lista de atributos que você acha que explicam bem a variação em seus dados.
Use o procedimento a seguir para extrair atributos de seus dados de séries temporais.
1. Abra seu fluxo de dados do Data Wrangler.
1. Se você não importou seu conjunto de dados, importe-o na guia **Importar dados**.
1. No seu fluxo de dados, em **Tipos de dados**, escolha o **\$1** e selecione **Adicionar transformação**.
1. Escolha **Adicionar etapa**.
1. Escolha **Extrair atributos**.
1. Em **Extrair atributos para esta coluna**, escolha uma coluna.
1. (Opcional) Selecione **Nivelado** para gerar os atributos em colunas separadas.
1. Em **Estratégia**, escolha uma estratégia para extrair os atributos.
1. Escolha **Visualizar** para gerar uma visualização prévia da transformação.
1. Escolha **Adicionar** para adicionar a transformação ao fluxo de dados do Data Wrangler.
### Use atributos atrasados de seus dados de séries temporais
Para muitos casos de uso, a melhor maneira de prever o comportamento futuro de sua série temporal é usar o comportamento mais recente.
Os usos mais comuns de atributos atrasados são os seguintes:
+ Coletando um punhado de valores passados. Por exemplo, para o tempo, t \$1 1, você coleta t, t - 1, t - 2 e t - 3.
+ Coletando valores que correspondem ao comportamento sazonal nos dados. Por exemplo, para prever a ocupação em um restaurante às 13h, convém usar os atributos a partir das 13h do dia anterior. Usar os atributos a partir das 12h ou 11h no mesmo dia pode não ser tão preditivo quanto usar os atributos dos dias anteriores.
1. Abra seu fluxo de dados do Data Wrangler.
1. Se você não importou seu conjunto de dados, importe-o na guia **Importar dados**.
1. No seu fluxo de dados, em **Tipos de dados**, escolha o **\$1** e selecione **Adicionar transformação**.
1. Escolha **Adicionar etapa**.
1. Selecione os **Atributos com atraso**.
1. Em **Gerar atributos de atraso para essa coluna**, escolha uma coluna.
1. Na **Coluna timestamp**, escolha a coluna contendo timestamps.
1. Para **Lag**, especifique a duração do atraso.
1. (Opcional) Configure a saída usando uma das seguintes opções:
+ **Incluir toda a janela de atraso**
+ **Nivelar a saída**
+ **Eliminar linhas sem histórico**
1. Escolha **Visualizar** para gerar uma visualização prévia da transformação.
1. Escolha **Adicionar** para adicionar a transformação ao fluxo de dados do Data Wrangler.
### Crie um intervalo de data e hora em sua série temporal
Talvez você tenha dados de séries temporais que não tenham timestamps. Se você sabe que as observações foram feitas em intervalos regulares, você pode gerar timestamps para a série temporal em uma coluna separada. Para gerar timestamps, você especifica o valor do carimbo de data/hora inicial e a frequência dos timestamps.
Por exemplo, você pode ter os seguintes dados de séries temporais para o número de clientes em um restaurante:
Dados de séries temporais sobre o número de clientes em um restaurante
| Número de clientes |
| --- |
| 10 |
| 14 |
| 24 |
| 40 |
| 30 |
| 20 |
Se você souber que o restaurante abriu às 17h e que as observações são feitas de hora em hora, você pode adicionar uma coluna de timestamp que corresponda aos dados da série temporal. É possível ver a coluna de timestamp na tabela a seguir.
Dados de séries temporais sobre o número de clientes em um restaurante
| Número de clientes | Timestamp |
| --- | --- |
| 10 | 13:00h |
| 14 | 14:00h |
| 24 | 15:00h |
| 40 | 16:00h |
| 30 | 17:00h |
| 20 | 18:00h |
Use o procedimento a seguir para adicionar um intervalo de data e hora aos seus dados.
1. Abra seu fluxo de dados do Data Wrangler.
1. Se você não importou seu conjunto de dados, importe-o na guia **Importar dados**.
1. No seu fluxo de dados, em **Tipos de dados**, escolha o **\$1** e selecione **Adicionar transformação**.
1. Escolha **Adicionar etapa**.
1. Escolha **Intervalo de data e hora**.
1. Em **Tipo de frequência**, escolha a unidade usada para medir a frequência de timestamps.
1. Em **Começando o timestamp**, especifique o início do timestamp.
1. Em **Coluna de saída**, especifique um nome para a coluna de saída.
1. (Opcional) Configure a saída usando os campos restantes.
1. Escolha **Visualizar** para gerar uma visualização prévia da transformação.
1. Escolha **Adicionar** para adicionar a transformação ao fluxo de dados do Data Wrangler.
### Use uma janela contínua em sua série temporal
Você pode extrair atributos ao longo de um período de tempo. Por exemplo, para o tempo, *t*, e uma janela de tempo de comprimento 3, e para a linha que indica o timestamp *t*, anexamos os atributos extraídas da série temporal nos momentos *t* - 3, *t* - 2 e *t* - 1. Para obter informações sobre como extrair atributos, consulte [Extrair atributos de seus dados de séries temporais](#data-wrangler-transform-extract-time-series-features).
É possível usar o procedimento a seguir para extrair atributos em um período.
1. Abra seu fluxo de dados do Data Wrangler.
1. Se você não importou seu conjunto de dados, importe-o na guia **Importar dados**.
1. No seu fluxo de dados, em **Tipos de dados**, escolha o **\$1** e selecione **Adicionar transformação**.
1. Escolha **Adicionar etapa**.
1. Escolha **Atributos da janela contínua**.
1. Em **Gerar atributos de janela contínua para esta coluna**, escolha uma coluna.
1. Na **Coluna timestamp**, escolha a coluna contendo timestamps.
1. (Opcional) Em **Coluna de saída**, especifique o nome da coluna de saída.
1. Em **Tamanho da janela**, especifique o tamanho da janela.
1. Em **Estratégia**, escolha uma estratégia para extrair os atributos.
1. Escolha **Visualizar** para gerar uma visualização prévia da transformação.
1. Escolha **Adicionar** para adicionar a transformação ao fluxo de dados do Data Wrangler.
## Destacar data e hora
Use **Destacar data/hora** para criar uma incorporação vetorial representando um campo de data e hora. Para usar essa transformação, os dados de data e hora devem estar em um dos seguintes formatos:
+ Segmentos que descrevem a data e hora: Por exemplo, `"January 1st, 2020, 12:44pm"`.
+ Um timestamp Unix: um timestamp Unix descreve o número de segundos, milissegundos, microssegundos ou nanossegundos a partir de 1/1/1970.
Você pode escolher **inferir o formato de data e hora** e fornecer um **formato de data e hora**. Se você fornecer um formato de data e hora, deverá usar os códigos descritos na [documentação do Python](https://docs.python.org/3/library/datetime.html#strftime-and-strptime-format-codes). As opções selecionadas para essas duas configurações têm implicações na velocidade da operação e nos resultados finais.
+ A opção mais manual e computacionalmente mais rápida é especificar um **Formato de data e hora** e selecionar **Não** para **Inferir formato de data e hora**.
+ Para reduzir o trabalho manual, você pode escolher **Inferir formato de data e hora** e não especificar um formato de data e hora. É também uma operação computacionalmente rápida; entretanto, o primeiro formato de data e hora encontrado na coluna de entrada é considerado o formato da coluna inteira. Se houver outros formatos na coluna, esses valores serão NaN na saída final. Inferir o formato de data e hora pode fornecer segmentos não analisados.
+ Se você não especificar um formato e selecionar **Não** para **Inferir formato de data e hora**, obterá os resultados mais robustos. Todos os segmentos de data e hora válidos são analisados. No entanto, essa operação pode ser uma ordem de magnitude mais lenta do que as duas primeiras opções dessa lista.
Ao usar essa transformação, você especifica uma **coluna de entrada** que contém dados de data e hora em um dos formatos listados acima. A transformação cria uma coluna de saída chamada **Nome da coluna de saída**. O formato da coluna de saída depende da sua configuração usando o seguinte:
+ **Vetor**: gera uma única coluna como vetor.
+ **Colunas**: cria uma nova coluna para cada atributo. Por exemplo, se a saída tiver um ano, mês e dia, três colunas separadas serão criadas para ano, mês e dia.
Além disso, você deve escolher um **modo de incorporação**. Para modelos lineares e redes profundas, recomendamos escolher o **cíclico**. **Para algoritmos baseados em árvore, recomendamos escolher ordinal.**
## Formatar segmento
As transformações **Formatar segmento** contêm operações de formatação de segmento padrão. Por exemplo, você pode usar essas operações para remover caracteres especiais, normalizar comprimentos de segmentos e atualizar maiúsculas e minúsculas.
Esse grupo de atributos contém as seguintes transformações: Todas as transformações retornam cópias de segmentos na **coluna Entrada** e adicionam o resultado a uma nova coluna de saída.
| Nome | Função |
| --- | --- |
| Almofada esquerda | Pressione com o botão esquerdo o segmento com um determinado **caractere de preenchimento** até a **largura especificada.** Se o segmento for maior que a **largura**, o valor de retorno será reduzido para caracteres de **largura**. |
| Almofada direita | Preencha com o botão direito o segmento com um determinado **caractere de preenchimento** até a **largura** especificada. Se o segmento for maior que a **largura**, o valor de retorno será reduzido para caracteres de **largura**. |
| Centro (almofadas em ambos os lados) | Coloque o segmento no centro (adicione preenchimento nos dois lados do segmento) com um determinado **caractere de preenchimento** até a **largura** especificada. Se o segmento for maior que a **largura**, o valor de retorno será reduzido para caracteres de **largura**. |
| Acrescentar zeros à esquerda | Preencha à esquerda um segmento numérico com zeros, até uma determinada **largura**. Se o segmento for maior que a **largura**, o valor de retorno será reduzido para caracteres de **largura**. |
| Remova à esquerda e à direita | Retorna uma cópia do segmento com os caracteres iniciais e finais removidos. |
| Remova os caracteres da esquerda | Retorna uma cópia de segmento com os caracteres iniciais removidos. |
| Remova os caracteres da direita | Retorna uma cópia do segmento com os caracteres finais removidos. |
| Letras minúsculas | Converta todas as letras do texto em letras minúsculas. |
| Letras maiúsculas | Converta todas as letras do texto em letras maiúsculas. |
| Capitalizar | Coloque a primeira letra em maiúscula em cada frase. |
| Alternar letra maiúscula e minúscula | Converte todos os caracteres maiúsculos em minúsculos e todos os caracteres minúsculos em caracteres maiúsculos de segmento fornecida e o retorna. |
| Adicionar prefixo ou sufixo | Adiciona um prefixo e um sufixo à coluna do segmento. Você deve especificar pelo menos um dos **Prefixos** e **Sufixos**. |
| Remover símbolos | Remove os símbolos fornecidos de um segmento. Todos os caracteres listados são removidos. O padrão é espaço em branco. |
## Lidar com valores discrepantes
Os modelos de machine learning são sensíveis à distribuição e ao alcance dos valores de seus atributos. Valores discrepantes, ou valores raros, podem afetar negativamente a precisão do modelo e levar a tempos de treinamento mais longos. Use esse grupo de atributos para detectar e atualizar valores discrepantes em seu conjunto de dados.
Quando você define uma etapa de transformação **Lidar com valores discrepantes**, as estatísticas usadas para detectar valores discrepantes são geradas nos dados disponíveis no Data Wrangler ao definir essa etapa. Essas mesmas estatísticas são usadas ao executar um trabalho do Data Wrangler.
Use as seções a seguir para saber mais sobre as transformações que este grupo contém. Você especifica um **nome de saída** e cada uma dessas transformações gera uma coluna de saída com os dados resultantes.
### Valores discrepantes numéricos robustos de desvio padrão
Essa transformação detecta e corrige valores discrepantes em atributos numéricos usando estatísticas que são robustas a valores discrepantes.
Você deve definir um **quantil superior** e um **quantil inferior** para as estatísticas usadas para calcular valores discrepantes. Você também deve especificar o número de **desvios padrão** dos quais um valor deve variar da média para ser considerado um valor atípico. Por exemplo, se você especificar 3 para **desvios padrão**, um valor deve ser de mais de 3 desvios padrão da média para ser considerado um valor atípico.
O **Método Fix** é o método usado para lidar com valores discrepantes quando eles são detectados. Você pode escolher entre as seguintes opções:
+ **Clipe**: use essa opção para recortar os valores discrepantes no limite de detecção de valores discrepantes correspondente.
+ **Remover**: use essa opção para remover linhas com valores discrepantes do dataframe.
+ **Invalidar**: use essa opção para substituir valores discrepantes por valores inválidos.
### Valores atípicos numéricos de desvio padrão
Essa transformação detecta e corrige valores discrepantes em atributos numéricos usando a média e o desvio padrão.
Você especifica o número de **desvios padrão** dos quais um valor deve variar da média para ser considerado um valor atípico. Por exemplo, se você especificar 3 para **desvios padrão**, um valor deve ser de mais de 3 desvios padrão da média para ser considerado um valor atípico.
O **Método Fix** é o método usado para lidar com valores discrepantes quando eles são detectados. Você pode escolher entre as seguintes opções:
+ **Clipe**: use essa opção para recortar os valores discrepantes no limite de detecção de valores discrepantes correspondente.
+ **Remover**: use essa opção para remover linhas com valores discrepantes do dataframe.
+ **Invalidar**: use essa opção para substituir valores discrepantes por valores inválidos.
### Valores atípicos numéricos quantílicos
Use esta transformação para detectar e corrigir valores discrepantes em atributos numéricos usando quantis. Você pode definir um **quantil superior** e um **quantil inferior**. Todos os valores que ficam acima do quantil superior ou abaixo do quantil inferior são considerados discrepantes.
O **Método Fix** é o método usado para lidar com valores discrepantes quando eles são detectados. Você pode escolher entre as seguintes opções:
+ **Clipe**: use essa opção para recortar os valores discrepantes no limite de detecção de valores discrepantes correspondente.
+ **Remover**: use essa opção para remover linhas com valores discrepantes do dataframe.
+ **Invalidar**: use essa opção para substituir valores discrepantes por valores inválidos.
### Valores discrepantes numéricos mínimo-máximos
Essa transformação detecta e corrige valores discrepantes em atributos numéricos usando limites superiores e inferiores. Use esse método se você conhece valores limite que demarcam valores discrepantes.
Você especifica um **limite superior** e um **limite inferior** e, se os valores ficarem acima ou abaixo desses limites, respectivamente, eles serão considerados valores discrepantes.
O **Método Fix** é o método usado para lidar com valores discrepantes quando eles são detectados. Você pode escolher entre as seguintes opções:
+ **Clipe**: use essa opção para recortar os valores discrepantes no limite de detecção de valores discrepantes correspondente.
+ **Remover**: use essa opção para remover linhas com valores discrepantes do dataframe.
+ **Invalidar**: use essa opção para substituir valores discrepantes por valores inválidos.
### Substituir valores raros
Ao usar a transformação **Substituir valores raros**, você especifica um limite e o Data Wrangler localiza todos os valores que atendem a esse limite e os substitui por um segmento especificado por você. Por exemplo, talvez você queira usar essa transformação para categorizar todos os valores atípicos em uma coluna em uma categoria “Outros”.
+ **Segmento de substituição**: a sequência com a qual substituir valores discrepantes.
+ **Limite absoluto**: uma categoria é rara se o número de instâncias for menor ou igual a esse limite absoluto.
+ **Limite de fração**: uma categoria é rara se o número de instâncias for menor ou igual a esse limite de fração multiplicado pelo número de linhas.
+ **Máximo de categorias comuns**: máximo de categorias não raras que permanecem após a operação. Se o limiar não filtrar categorias suficientes, aquelas com o maior número de ocorrências são classificadas como não raras. Se definido como 0 (padrão), não há limite rígido para o número de categorias.
## Processamento de valores ausentes
Valores ausentes são uma ocorrência comum em conjuntos de dados de machine learning. Em algumas situações, é apropriado imputar aos dados faltantes um valor calculado, como um valor médio ou categoricamente comum. Você pode processar valores ausentes usando o grupo de transformação **Processar valores ausentes**. Esse grupo contém as seguintes transformações:
### Preencher valores ausentes
Use a transformação **Preencher valores ausentes** para substituir valores ausentes por um **valor do preenchimento** definido por você.
### Imputar valores ausentes
Use a transformação de **Imputar valores ausentes** para criar uma nova coluna que contenha valores imputados onde valores ausentes foram encontrados nos dados de entrada categóricos e numéricos. A configuração depende do seu tipo de dados.
Para dados numéricos, escolha uma estratégia de imputação, a estratégia usada para determinar o novo valor a ser imputado. Você pode optar por imputar a média ou a mediana sobre os valores que estão presentes no seu conjunto de dados. O Data Wrangler usa o valor que ele computa para imputar os valores ausentes.
Para dados categóricos, o Data Wrangler imputa valores ausentes usando o valor mais frequente na coluna. Para imputar um segmento personalizado, use a transformação **Preenchimento ausente** em vez disso.
### Adicionar indicador de valores ausentes
Use a transformação **Adicionar indicador para valores ausentes** para criar uma nova coluna indicadora, que contém um booleano `"false"` se uma linha contiver um valor e `"true"` se uma linha contiver um valor ausente.
### Eliminar valores ausentes
Use a opção **Eliminar valores ausentes** para remover linhas que contêm valores ausentes da **Coluna de entrada**.
## Gerenciar colunas
Você pode usar as seguintes transformações para atualizar e gerenciar rapidamente as colunas no seu conjunto de dados:
| Nome | Função |
| --- | --- |
| Soltar coluna | Exclua uma coluna. |
| Duplicar coluna | Duplique uma coluna. |
| Renomear coluna | Renomeie uma coluna. |
| Mover coluna | Mova a localização de uma coluna no conjunto de dados. Escolha mover sua coluna para o início ou o final do conjunto de dados, antes ou depois de uma coluna de referência ou para um índice específico. |
## Gerenciar linhas
Use esse grupo de transformação para executar rapidamente as operações de classificação e reprodução aleatória nas linhas. Este grupo contém o seguinte:
+ **Classificar**: classifique todo o dataframe por uma determinada coluna. Marque a caixa de seleção ao lado de **Ordem crescente** para essa opção; caso contrário, desmarque a caixa de seleção e a ordem decrescente será usada para a classificação.
+ **Embaralhar**: embaralhe aleatoriamente todas as linhas no conjunto de dados.
## Gerenciar vetores
Use esse grupo de transformação para combinar ou nivelar colunas vetoriais. Esse grupo contém as seguintes transformações:
+ **Montar**: use essa transformação para combinar vetores e dados numéricos do Spark em uma única coluna. Por exemplo, você pode combinar três colunas: duas contendo dados numéricos e uma contendo vetores. Adicione todas as colunas que você deseja combinar nas **colunas de entrada** e especifique um **nome de coluna de saída** para os dados combinados.
+ **Nivelar**: use essa transformação para nivelar uma única coluna contendo dados vetoriais. A coluna de entrada deve conter PySpark vetores ou objetos semelhantes a matrizes. Você pode controlar o número de colunas criadas especificando um **método para detectar o número de saídas**. Por exemplo, se você selecionar **Comprimento do primeiro vetor**, o número de elementos no primeiro vetor ou matriz válido encontrado na coluna determinará o número de colunas de saída criadas. Todos os outros vetores de entrada com muitos itens serão truncados. As entradas com poucos itens são preenchidas com NaNs.
Você também especifica um **prefixo de saída**, que é usado como prefixo para cada coluna de saída.
## Processo numérico
Use o grupo de atributos **Processar numérico** para processar dados numéricos. Cada escalar desse grupo é definido usando a biblioteca Spark. Os seguintes escalares são compatíveis:
+ **Escalonador padrão**: padronize a coluna de entrada subtraindo a média de cada valor e dimensionando para a variação unitária. Para saber mais, consulte a documentação do Spark para [StandardScaler](https://docs.aws.amazon.com/sagemaker/latest/dg/data-wrangler-transform.html).
+ **Escalonador robusto**: escale a coluna de entrada usando estatísticas que são robustas a valores discrepantes. Para saber mais, consulte a documentação do Spark para [RobustScaler](https://spark.apache.org/docs/latest/ml-features#robustscaler).
+ **Escalonador mínimo máximo**: transforme a coluna de entrada escalando cada atributo para um determinado intervalo. Para saber mais, consulte a documentação do Spark para [MinMaxScaler](https://spark.apache.org/docs/latest/ml-features#minmaxscaler).
+ **Escalonador absoluto máximo**: escale a coluna de entrada dividindo cada valor pelo valor absoluto máximo. Para saber mais, consulte a documentação do Spark para [MaxAbsScaler](https://spark.apache.org/docs/latest/ml-features#maxabsscaler).
## Amostragem
Depois de importar seus dados, você pode usar o transformador de **amostragem** para coletar uma ou mais amostras deles. Quando você usa o transformador de amostragem, o Data Wrangler coleta amostras do seu conjunto de dados original.
Você pode escolher um dos seguintes métodos de amostra:
+ **Limite**: faça uma amostra do conjunto de dados a partir da primeira linha até o limite que você especificar.
+ **Aleatório**: obtém uma amostra aleatória de um tamanho especificado por você.
+ **Estratificado**: obtém uma amostra aleatória estratificada.
Você pode estratificar uma amostra aleatória para garantir que ela represente a distribuição original do conjunto de dados.
Você pode estar realizando a preparação de dados para vários casos de uso. Para cada caso de uso, você pode pegar uma amostra diferente e aplicar um conjunto diferente de transformações.
O procedimento a seguir descreve o processo de criar uma amostra aleatória.
Para obter uma amostra aleatória dos seus dados.
1. Escolha o **\$1** à direita do conjunto de dados que você importou. O nome do seu conjunto de dados está localizado abaixo do **\$1**.
1. Escolha **Adicionar transformação**.
1. Escolha **Amostragem**.
1. Para **Método de amostragem**, escolha o método de amostragem.
1. Em **Tamanho aproximado da amostra**, escolha o número aproximado de observações que você deseja em sua amostra.
1. (Opcional) Especifique um número inteiro para **Semente aleatória** para criar uma amostra reproduzível.
O procedimento a seguir descreve o processo de criação de uma amostra estratificada.
Para obter uma amostra estratificada de seus dados.
1. Escolha o **\$1** à direita do conjunto de dados que você importou. O nome do seu conjunto de dados está localizado abaixo do **\$1**.
1. Escolha **Adicionar transformação**.
1. Escolha **Amostragem**.
1. Para **Método de amostragem**, escolha o método de amostragem.
1. Em **Tamanho aproximado da amostra**, escolha o número aproximado de observações que você deseja em sua amostra.
1. Em **Estratificar coluna**, especifique o nome da coluna na qual você deseja estratificar.
1. (Opcional) Especifique um número inteiro para **Semente aleatória** para criar uma amostra reproduzível.
## Pesquisar e editar
Use esta seção para pesquisar e editar padrões específicos em segmentos. Por exemplo, você pode localizar e atualizar segmentos em frases ou documentos, dividir segmentos por delimitadores e localizar ocorrências de segmentos específicos.
As seguintes transformações são compatíveis com **Pesquisar e editar**: Todas as transformações retornam cópias de segmentos na **Coluna Entrada** e adicionam o resultado a uma nova coluna de saída.
| Nome | Função |
| --- | --- |
| Encontre um sub-segmento | Retorna o índice da primeira ocorrência do **Sub-segmento** pela qual você pesquisou. Você pode iniciar e terminar a pesquisa no **Início** e no **Fim**, respectivamente. |
| Encontre um sub-segmento (da direita) | Retorna o índice da última ocorrência do **Sub-segmento** que você pesquisou. Você pode iniciar e finalizar a pesquisa no **Início** e no **Fim**, respectivamente. |
| Corresponde ao prefixo | Retorna um valor booleano se o segmento tiver um determinado **padrão**. Um padrão pode ser uma sequência de caracteres ou uma expressão regular. Opcionalmente, você pode diferenciar o padrão de maiúsculas e minúsculas. |
| Encontre todas as ocorrências | Retorna uma matriz com todas as ocorrências de um determinado padrão. Um padrão pode ser uma sequência de caracteres ou uma expressão regular. |
| Extrair usando regex | Retorna um segmento que corresponde a um determinado padrão regex. |
| Extrair entre delimitadores | Retorna um segmento com todos os caracteres encontrados entre o **delimitador esquerdo** e o **delimitador direito**. |
| Extrair da posição | Retorna um segmento, começando da **posição inicial** no segmento de entrada, que contém todos os caracteres até a posição inicial mais o **comprimento**. |
| Encontre e substitua a sub-segmento | Retorna um segmento com todas as correspondências de um determinado **padrão** (expressão regular) substituída pelo **segmento de substituição**. |
| Substituir entre delimitadores | Retorna um segmento com a sub-segmento encontrada entre a primeira aparição de um **delimitador esquerdo** e a última aparição de um **delimitador direito** substituída pelo **segmento de substituição**. Se nenhuma correspondência for encontrada, nada é substituído. |
| Substituir da posição | Retorna um segmento com a sub-segmento entre a **posição inicial** e a **posição inicial** mais o **comprimento** substituída pelo **segmento de substituição**. Se a **posição inicial** mais o **comprimento** for maior que o comprimento de segmento de substituição, a saída conterá**...**. |
| Converter regex para ausente | Converte um segmento em `None` se for inválido e retorna o resultado. A validade é definida com uma expressão regular em **Padrão**. |
| Dividir segmento por delimitador | Retorna uma matriz de srtrings da string de entrada, dividida por **Delimitador**, com até o **Número máximo de divisões** (opcional). O delimitador usa como padrão o espaço em branco. |
## Dividir dados
Use a transformação **Dividir dados** para dividir seu conjunto de dados em dois ou três conjuntos de dados. Por exemplo, você pode dividir seu conjunto de dados em um conjunto de dados usado para treinar seu modelo e um conjunto de dados usado para testá-lo. Você pode determinar a proporção do conjunto de dados que entra em cada divisão. Por exemplo, se você estiver dividindo um conjunto de dados em dois conjuntos, o conjunto de treinamento pode ter 80% dos dados, enquanto o conjunto de teste terá 20%.
A divisão de seus dados em três conjuntos de dados permite criar conjuntos de dados de treinamento, validação e teste. Você pode ver o desempenho do modelo no conjunto de dados de teste eliminando a coluna de destino.
Seu caso de uso determina quanto do conjunto de dados original cada um de seus conjuntos de dados obtém e o método usado para dividir os dados. Por exemplo, você pode querer usar uma divisão estratificada para garantir que a distribuição das observações na coluna alvo seja a mesma em todos os conjuntos de dados. Você pode usar as seguintes transformações divididas:
+ Divisão aleatória: Cada divisão é uma amostra aleatória e não sobreposta do conjunto de dados original. Para conjuntos de dados maiores, utilizar uma divisão aleatória pode ser computacionalmente custoso e levar mais tempo do que uma divisão ordenada.
+ Divisão ordenada: divide o conjunto de dados com base na ordem sequencial das observações. Por exemplo, em uma divisão de treino/teste de 80/20, as primeiras observações que compõem 80% do conjunto de dados são destinadas ao conjunto de treinamento. Os últimos 20% das observações vão para o conjunto de dados de teste. As divisões ordenadas são eficazes para manter a ordem existente dos dados entre as divisões.
+ Divisão estratificada: divide o conjunto de dados para garantir que o número de observações na coluna de entrada tenha representação proporcional. Para uma coluna de entrada que possui as observações 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, uma divisão de 80/20 nessa coluna significaria que aproximadamente 80% dos 1s, 80% dos 2s e 80% dos 3s iriam para o conjunto de treinamento. Cerca de 20% de cada tipo de observação vai para o conjunto de testes.
+ Dividir por chave: evita que dados com a mesma chave ocorram em mais de uma divisão. Por exemplo, se você tiver um conjunto de dados com a coluna “customer\$1id” e o estiver usando como chave, nenhum ID de cliente estará em mais de uma divisão.
Depois de dividir os dados, você pode aplicar transformações adicionais a cada conjunto de dados. Para a maioria dos casos de uso, eles não são necessários.
O Data Wrangler calcula as proporções das divisões para desempenho. Você pode escolher um limite de erro para definir a precisão das divisões. Limites de erro mais baixos refletem de forma mais precisa as proporções que você especifica para as divisões. Se você definir um limite de erro mais alto, obterá melhor desempenho, mas menor precisão.
Para dividir perfeitamente os dados, defina o limite de erro como 0. Você pode especificar um limite entre 0 e 1 para melhorar o desempenho. Se você especificar um valor maior que 1, o Data Wrangler interpretará esse valor como 1.
Se você tiver 10.000 linhas em seu conjunto de dados e especificar uma divisão 80/20 com um erro de 0,001, obterá observações que se aproximam de um dos seguintes resultados:
+ 8010 observações no conjunto de treinamento e 1990 no conjunto de testes
+ 7990 observações no conjunto de treinamento e 2010 no conjunto de testes
O número de observações para o conjunto de testes no exemplo anterior está no intervalo entre 8010 e 7990.
Por padrão, o Data Wrangler usa uma semente aleatória para tornar as divisões reproduzíveis. Você pode especificar um valor diferente para a semente para criar uma divisão reproduzível diferente.
------
#### [ Randomized split ]
Use o procedimento a seguir para realizar uma divisão aleatória em seu conjunto de dados.
Para dividir seu conjunto de dados aleatoriamente, faça o seguinte
1. Escolha o **\$1** ao lado do nó que contém o conjunto de dados que você está dividindo.
1. Escolha **Adicionar transformação**.
1. Escolha **Dividir dados**.
1. (Opcional) Para **Divisões**, especifique os nomes e as proporções de cada divisão. As proporções devem somar 1.
1. (Opcional) Escolha o **\$1** para criar uma divisão adicional.
1. Especifique os nomes e as proporções de todas as divisões. As proporções devem somar 1.
1. (Opcional) Especifique um valor para o **Limite de erro** diferente do valor padrão.
1. (Opcional) Especifique um valor para a **Semente aleatória**.
1. Escolha **Pré-visualizar**.
1. Escolha **Adicionar**.
------
#### [ Ordered split ]
Use o procedimento a seguir para realizar uma divisão ordenada em seu conjunto de dados.
Para fazer uma divisão ordenada em seu conjunto de dados, faça o seguinte:
1. Escolha o **\$1** ao lado do nó que contém o conjunto de dados que você está dividindo.
1. Escolha **Adicionar transformação**.
1. Em **Transformação**, escolha **Divisão ordenada**.
1. Escolha **Dividir dados**.
1. (Opcional) Para **Divisões**, especifique os nomes e as proporções de cada divisão. As proporções devem somar 1.
1. (Opcional) Escolha o **\$1** para criar uma divisão adicional.
1. Especifique os nomes e as proporções de todas as divisões. As proporções devem somar 1.
1. (Opcional) Especifique um valor para o **Limite de erro** diferente do valor padrão.
1. (Opcional) Para **Coluna de entrada**, especifique uma coluna com valores numéricos. Usa os valores das colunas para inferir quais registros estão em cada divisão. Os valores menores estão em uma divisão com os valores maiores nas outras divisões.
1. (Opcional) Selecione **Lidar com duplicatas** para adicionar ruído aos valores duplicados e criar um conjunto de dados com valores totalmente exclusivos.
1. (Opcional) Especifique um valor para a **Semente aleatória**.
1. Escolha **Pré-visualizar**.
1. Escolha **Adicionar**.
------
#### [ Stratified split ]
Use o procedimento a seguir para realizar uma divisão estratificada em seu conjunto de dados.
Para realizar uma divisão estratificada no seu conjunto de dados, faça o seguinte:
1. Escolha o **\$1** ao lado do nó que contém o conjunto de dados que você está dividindo.
1. Escolha **Adicionar transformação**.
1. Escolha **Dividir dados**.
1. Em **Transformação**, escolha **Divisão estratificada.**
1. (Opcional) Para **Divisões**, especifique os nomes e as proporções de cada divisão. As proporções devem somar 1.
1. (Opcional) Escolha o **\$1** para criar uma divisão adicional.
1. Especifique os nomes e as proporções de todas as divisões. As proporções devem somar 1.
1. Para **Coluna de entrada**, especifique uma coluna com até 100 valores exclusivos. O Data Wrangler não pode estratificar uma coluna com mais de 100 valores exclusivos.
1. (Opcional) Especifique um valor para o **Limite de erro** diferente do valor padrão.
1. (Opcional) Especifique um valor para **Semente aleatória** para especificar uma semente diferente.
1. Escolha **Pré-visualizar**.
1. Escolha **Adicionar**.
------
#### [ Split by column keys ]
Use o procedimento a seguir para dividir pelas chaves de coluna em seu conjunto de dados.
Para dividir pelas chaves de coluna em seu conjunto de dados, faça o seguinte:
1. Escolha o **\$1** ao lado do nó que contém o conjunto de dados que você está dividindo.
1. Escolha **Adicionar transformação**.
1. Escolha **Dividir dados**.
1. Em **Transformação**, escolha **Dividir por chave**.
1. (Opcional) Para **Divisões**, especifique os nomes e as proporções de cada divisão. As proporções devem somar 1.
1. (Opcional) Escolha o **\$1** para criar uma divisão adicional.
1. Especifique os nomes e as proporções de todas as divisões. As proporções devem somar 1.
1. Para **Colunas-chave**, especifique as colunas com valores que você não deseja que apareçam nos dois conjuntos de dados.
1. (Opcional) Especifique um valor para o **Limite de erro** diferente do valor padrão.
1. Escolha **Pré-visualizar**.
1. Escolha **Adicionar**.
------
## Analisar valor como tipo
Use essa transformação para converter uma coluna em um novo tipo. Os tipos de dados do Data Wrangler compatíveis são:
+ Longo
+ Float
+ Booleano
+ Data, no formato dd-MM-yyyy, representando dia, mês e ano, respectivamente.
+ String
## Validar segmento
Use as transformações **Validar segmento** para criar uma nova coluna que indica que uma linha de dados de texto atende a uma condição especificada. Por exemplo, você pode usar uma transformação **Validar segmento** para verificar se um segmento contém somente caracteres minúsculos. As seguintes transformações são compatíveis com **Validar segmento**:
As seguintes transformações estão incluídas nesse grupo de transformações: Se uma transformação gerar um valor booleano, `True` é representada com a `1` e `False` é representada com a `0`.
| Nome | Função |
| --- | --- |
| Tamanho da segmento | Retorna `True` se o comprimento de um segmento for igual ao comprimento especificado. Caso contrário, gera `False`. |
| Inicia com | Retorna `True` se um segmento começar com um prefixo especificado. Caso contrário, gera `False`. |
| Termina com | Retorna `True` se o comprimento de um segmento for igual ao comprimento especificado. Caso contrário, gera `False`. |
| É alfanumérico | Retorna `True` se um segmento tiver apenas números e letras. Caso contrário, gera `False`. |
| É alfa (letras) | Retorna `True` se um segmento tiver apenas letras. Caso contrário, gera `False`. |
| É dígito | Retorna `True` se um segmento tiver apenas dígitos. Caso contrário, gera `False`. |
| É espaço | Retorna `True` se um segmento tiver apenas números e letras. Caso contrário, gera `False`. |
| É título | Retorna `True` se um segmento tiver algum espaço em branco. Caso contrário, gera `False`. |
| Está em letra minúscula | Retorna `True` se um segmento tiver apenas letras minúsculas. Caso contrário, gera `False`. |
| Está em letra maiúscula | Retorna `True` se um segmento tiver apenas letras maiúsculas. Caso contrário, gera `False`. |
| É numérico | Retorna `True` se um segmento tiver apenas números. Caso contrário, gera `False`. |
| É decimal | Retorna `True` se um segmento tiver apenas números decimais. Caso contrário, gera `False`. |
## Desaninhar dados JSON
Se você tiver um arquivo.csv, talvez tenha valores em seu conjunto de dados que sejam segmentos JSON. Da mesma forma, você pode ter dados aninhados em colunas de um arquivo Parquet ou de um documento JSON.
Use o operador **estruturado nivelado** para separar as chaves de primeiro nível em colunas separadas. Uma chave de primeiro nível é uma chave que não está aninhada em um valor.
Por exemplo, você pode ter um conjunto de dados que tenha uma coluna *pessoa* com informações demográficas de cada pessoa armazenadas como segmentos JSON. Seu segmento JSON pode ser semelhante à seguinte:
```
"{"seq": 1,"name": {"first": "Nathaniel","last": "Ferguson"},"age": 59,"city": "Posbotno","state": "WV"}"
```
O operador **estruturado nivelado** converte as seguintes chaves de primeiro nível em colunas adicionais no seu conjunto de dados:
+ seq
+ name
+ idade
+ cidade
+ estado
O Data Wrangler coloca os valores das chaves como valores abaixo das colunas. Veja a seguir os nomes e valores das colunas do JSON.
```
seq, name, age, city, state
1, {"first": "Nathaniel","last": "Ferguson"}, 59, Posbotno, WV
```
Para cada valor em seu conjunto de dados contendo JSON, o operador **estruturado nivelado** cria colunas para as chaves de primeiro nível. Para criar colunas para chaves aninhadas, chame o operador novamente. Para o exemplo anterior, chamar o operador cria as colunas:
+ name\$1first
+ name\$1last
O exemplo a seguir mostra o conjunto de dados resultante de chamar a operação novamente.
```
seq, name, age, city, state, name_first, name_last
1, {"first": "Nathaniel","last": "Ferguson"}, 59, Posbotno, WV, Nathaniel, Ferguson
```
Escolha **Teclas para nivelar** para especificar as chaves de primeiro nível que você deseja extrair como colunas separadas. Se você não especificar nenhuma chave, o Data Wrangler extrairá todas as chaves por padrão.
## Explodir matriz
Use **Explode matriz** para expandir os valores da matriz em linhas de saída separadas. Por exemplo, a operação pode pegar cada valor na matriz, [[1, 2, 3,], [4, 5, 6], [7, 8, 9]] e criar uma nova coluna com as seguintes linhas:
```
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]
```
O Data Wrangler nomeia a nova coluna como input\$1column\$1name\$1flatten.
Você pode chamar a operação **Explodir matriz** várias vezes para colocar os valores aninhados da matriz em colunas de saída separadas. O exemplo a seguir mostra o resultado de chamar a operação várias vezes em um conjunto de dados com uma matriz aninhada.
Colocando os valores de uma matriz aninhada em colunas separadas
| id | array | id | array\$1items | id | array\$1items\$1items |
| --- | --- | --- | --- | --- | --- |
| 1 | [[gato, cachorro], [morcego, sapo]] | 1 | [gato, cachorro] | 1 | cat |
| 2 | [[rosa, petúnia], [lírio, margarida]] | 1 | [morcego, sapo] | 1 | dog |
| | | 2 | [rosa, petúnia] | 1 | bat |
| | | 2 | [lírio, margarida] | 1 | sapo |
| | | | 2 | 2 | rose |
| | | | 2 | 2 | petúnia |
| | | | 2 | 2 | lírio |
| | | | 2 | 2 | margarida |
## Transformar dados de imagem
Use o Data Wrangler para importar e transformar as imagens que você está usando para seus pipelines de machine learning (ML). Depois de preparar os dados de imagem, você pode exportá-los do fluxo do Data Wrangler para o pipeline de ML.
Você pode usar as informações fornecidas aqui para se familiarizar com a importação e transformação de dados de imagem no Data Wrangler. O Data Wrangler usa o OpenCV para importar imagens. Para obter mais informações sobre os formatos de imagem compatíveis, consulte [Leitura e gravação de arquivos de imagem](https://docs.opencv.org/3.4/d4/da8/group__imgcodecs.html#ga288b8b3da0892bd651fce07b3bbd3a56).
Depois de se familiarizar com os conceitos de transformação de seus dados de imagem, leia o tutorial a seguir, [Preparar dados de imagem com o Amazon SageMaker Data Wrangler](https://aws.amazon.com/blogs/machine-learning/prepare-image-data-with-amazon-sagemaker-data-wrangler/).
Os setores e casos de uso a seguir são exemplos nos quais a aplicação de machine learning a dados de imagem transformados pode ser útil:
+ Fabricação - Identificação de defeitos em itens da linha de montagem
+ Alimentação - Identificação de alimentos estragados ou deteriorados
+ Medicina - Identificação de lesões nos tecidos
Ao trabalhar com dados de imagem no Data Wrangler, você passa pelo seguinte processo:
1. Importar - Selecione as imagens escolhendo o diretório que as contém em seu bucket do Amazon S3.
1. Transformar - Use as transformações integradas para preparar as imagens para seu pipeline de machine learning.
1. Exportar: Exporte as imagens que você transformou para um local que possa ser acessado a partir do pipeline.
Use o seguinte procedimento para importar seus dados de imagem:
**Para importar seus dados de imagem**
1. Navegue até a página **Criar conexão**.
1. Escolha **Amazon S3**.
1. Especifique o caminho do arquivo do Amazon S3 que contém os dados de imagem.
1. Em **Tipo de arquivo**, escolha **Imagem**.
1. (Opcional) Escolha **Importar diretórios aninhados** para importar imagens de vários caminhos do Amazon S3.
1. Escolha **Importar**.
O Data Wrangler usa a biblioteca [imgaug](https://imgaug.readthedocs.io/en/latest/) de código aberto para suas transformações de imagem integradas. É possível usar as seguintes transformações internas:
+ **ResizeImage**
+ **EnhanceImage**
+ **CorruptImage**
+ **SplitImage**
+ **DropCorruptedImages**
+ **DropImageDuplicates**
+ **Brightness**
+ **ColorChannels**
+ **Grayscale**
+ **Rotate**
Use o procedimento a seguir para transformar suas imagens sem escrever código.
**Para transformar os dados de imagem sem escrever código**
1. No fluxo do Data Wrangler, escolha o **\$1** ao lado do nó que representa as imagens que você importou.
1. Escolha **Adicionar transformação**.
1. Escolha **Adicionar etapa**.
1. Escolha a transformação e configure-a.
1. Escolha **Pré-visualizar**.
1. Escolha **Adicionar**.
Além de usar as transformações fornecidas pelo Data Wrangler, você também pode usar seus próprios trechos de código personalizados. Para obter mais informações sobre como usar snippets de código personalizados, consulte [Transformações personalizadas](#data-wrangler-transform-custom). Você pode importar as bibliotecas OpenCV e imgaug em seus trechos de código e usar as transformações associadas a elas. O seguinte exemplo mostra um de um snippet de código que detecta bordas nas imagens:
```
# A table with your image data is stored in the `df` variable
import cv2
import numpy as np
from pyspark.sql.functions import column
from sagemaker_dataprep.compute.operators.transforms.image.constants import DEFAULT_IMAGE_COLUMN, IMAGE_COLUMN_TYPE
from sagemaker_dataprep.compute.operators.transforms.image.decorators import BasicImageOperationDecorator, PandasUDFOperationDecorator
@BasicImageOperationDecorator
def my_transform(image: np.ndarray) -> np.ndarray:
# To use the code snippet on your image data, modify the following lines within the function
HYST_THRLD_1, HYST_THRLD_2 = 100, 200
edges = cv2.Canny(image,HYST_THRLD_1,HYST_THRLD_2)
return edges
@PandasUDFOperationDecorator(IMAGE_COLUMN_TYPE)
def custom_image_udf(image_row):
return my_transform(image_row)
df = df.withColumn(DEFAULT_IMAGE_COLUMN, custom_image_udf(column(DEFAULT_IMAGE_COLUMN)))
```
Ao aplicar transformações em seu fluxo do Data Wrangler, o Data Wrangler as aplica somente a uma amostra das imagens em seu conjunto de dados. Para otimizar sua experiência com a aplicação, o Data Wrangler não aplica as transformações em todas as suas imagens.
Para aplicar as transformações em todas as suas imagens, exporte seu fluxo do Data Wrangler para um local do Amazon S3. Você pode usar as imagens que você exportou em seus pipelines de treinamento ou inferência. Use um nó de destino ou um caderno Jupyter para exportar seus dados. Você pode acessar qualquer um dos métodos para exportar seus dados do fluxo do Data Wrangler. Para obter mais informações sobre como usar esses métodos, consulte [Exportar para o Amazon S3.](data-wrangler-data-export.md#data-wrangler-data-export-s3).
## Filtrar dados
Use o Data Wrangler para filtrar os dados em suas colunas. Ao filtrar os dados em uma coluna, você especifica os seguintes campos:
+ **Nome da coluna**: O nome da coluna que você está usando para filtrar os dados.
+ **Condição**: O tipo de filtro que você está aplicando aos valores na coluna.
+ **Valor**: O valor ou a categoria na coluna à qual você está aplicando o filtro.
Você pode filtrar nas seguintes condições:
+ **=**: Retorna valores que correspondem ao valor ou categoria que você especifica.
+ **\$1=**: Retorna valores que correspondem ao valor ou categoria que você especifica.
+ **>=**: Para dados **longos** ou **flutuantes**, filtra valores maiores ou iguais ao valor especificado.
+ **<=**: Para dados **longos** ou **flutuantes**, filtra valores menores ou iguais ao valor especificado.
+ **>**: Para dados **longos** ou **flutuantes**, filtra valores maiores que o valor especificado.
+ **<**: Para dados **longos** ou **flutuantes**, filtra valores menores que o valor especificado.
Para uma coluna que tem as categorias `male` e `female`, você pode filtrar todos os valores `male`. Você também pode filtrar todos os valores `female`. Como há somente valores `male` e `female` na coluna, o filtro retorna uma coluna que só tem valores `female`.
Você também pode adicionar vários filtros. Os filtros podem ser aplicados em várias colunas ou na mesma coluna. Por exemplo, se você estiver criando uma coluna que só tem valores dentro de um determinado intervalo, você adiciona dois filtros diferentes. Um filtro especifica que a coluna deve ter valores maiores do que o valor fornecido. O outro filtro especifica que a coluna deve ter valores menores que o valor fornecido.
Use o procedimento a seguir para adicionar a transformação de filtro aos seus dados.
**Para filtrar seus dados**
1. No fluxo do Data Wrangler, escolha o **\$1** ao lado do nó com os dados que você está filtrando.
1. Escolha **Adicionar transformação**.
1. Escolha **Adicionar etapa**.
1. Escolha **Filtrar dados**.
1. Especifique os seguintes campos:
+ **Nome da coluna**: A coluna que você está filtrando.
+ **Condição**: A condição do filtro.
+ **Valor**: O valor ou a categoria na coluna à qual você está aplicando o filtro.
1. (Opcional) Escolha **\$1** seguindo o filtro que você criou.
1. Configure o filtro.
1. Escolha **Pré-visualizar**.
1. Escolha **Adicionar**.
## Colunas de mapas do Amazon Personalize
O Data Wrangler se integra ao Amazon Personalize, um serviço de machine learning totalmente gerenciado que gera recomendações de itens e segmentos de usuários. Você pode usar as **colunas do Mapa para transformar o Amazon Personalize** para colocar seus dados em um formato que o Amazon Personalize possa interpretar. Para obter mais informações sobre as transformações específicas do Amazon Personalize, [consulte Importação de dados usando o Amazon SageMaker Data Wrangler](https://docs.aws.amazon.com/personalize/latest/dg/preparing-importing-with-data-wrangler.html#dw-transform-data). Para obter mais informações sobre o Amazon Personalize, consulte [O que é o Amazon Personalize](https://docs.aws.amazon.com/personalize/latest/dg/what-is-personalize.html)?
# Analisar e visualizar
O Amazon SageMaker Data Wrangler inclui análises integradas que ajudam você a gerar visualizações e análises de dados com apenas alguns cliques. Você também pode criar análises personalizadas usando seu próprio código.
Você adiciona uma análise a um quadro de dados selecionando uma etapa em seu fluxo de dados e, em seguida, escolhendo **Adicionar análise**. Para acessar uma análise que você criou, selecione a etapa que contém a análise e selecione a análise.
Todas as análises são geradas usando 100.000 linhas do seu conjunto de dados.
Você pode adicionar a seguinte análise a um quadro de dados:
+ Visualizações de dados, incluindo histogramas e gráficos de dispersão.
+ Um resumo rápido do seu conjunto de dados, incluindo número de entradas, valores mínimos e máximos (para dados numéricos) e categorias mais e menos frequentes (para dados categóricos).
+ Um modelo rápido do conjunto de dados, que pode ser usado para gerar uma pontuação de importância para cada atributo.
+ Um relatório de vazamento de destino, que você pode usar para determinar se um ou mais atributos estão fortemente correlacionadas com seu atributo de destino.
+ Uma visualização personalizada usando seu próprio código.
Use as seguintes seções para saber mais sobre essas opções:
## Histograma
Use histogramas para ver as contagens dos valores de um atributo específico. Você pode inspecionar as relações entre os atributos usando a opção **Colorir por**. Por exemplo, o histograma a seguir mostra a distribuição das avaliações dos usuários dos livros mais vendidos na Amazon de 2009 a 2019, coloridos por gênero.
![\[Exemplo de gráfico de histograma no console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/histogram.png)
Você pode usar o recurso **Facet by** para criar histogramas de uma coluna, para cada valor em outra coluna. Por exemplo, o diagrama a seguir mostra histogramas das análises de usuários dos livros mais vendidos na Amazon, organizados por ano.
![\[Exemplos de histogramas no console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/review_by_year.png)
## Gráfico de dispersão
Use o atributo **Gráfico de dispersão** para inspecionar a relação entre os atributos. Para criar um gráfico de dispersão, selecione um atributo para plotar no **eixo X** e no **eixo Y.** Ambas as colunas devem ser colunas de tipo numérico.
Você pode colorir gráficos de dispersão usando uma coluna adicional. Por exemplo, o exemplo a seguir exibe um gráfico de dispersão que compara o número de análises em relação às análises dos usuários dos livros mais vendidos na Amazon entre 2009 e 2019. O gráfico de dispersão é colorido por gênero de livro.
![\[Exemplo de gráfico de dispersão no console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/scatter-plot.png)
Além disso, você pode facetar gráficos de dispersão por atributos. Por exemplo, a imagem a seguir mostra um exemplo do mesmo gráfico de dispersão de análises versus análises de usuários, facetado por ano.
![\[Exemplo de gráfico de dispersão facetado no console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/scatter-plot-facet.png)
## Resumo da tabela
Use a análise de **Resumo da tabela** para resumir rapidamente seus dados.
Para colunas com dados numéricos, incluindo dados de log e flutuantes, um resumo da tabela relata o número de entradas (contagem), mínimo (mínimo), máximo (máximo), média e desvio padrão (stddev) para cada coluna.
Para colunas com dados não numéricos, incluindo colunas com string, booleano ou date/time dados, um resumo da tabela relata o número de entradas (contagem), o valor menos frequente (mínimo) e o valor mais frequente (máximo).
## Modelo rápido
Use a visualização do **Modelo rápido** para avaliar rapidamente seus dados e produzir pontuações de importância para cada atributo. Uma [pontuação de importância de um atributo](http://spark.apache.org/docs/2.1.0/api/python/pyspark.ml.html#pyspark.ml.classification.DecisionTreeClassificationModel.featureImportances) indica a utilidade de um atributo na previsão de um rótulo de destino. A pontuação de importância do atributo está entre [0, 1] e um número maior indica que o atributo é mais importante para todo o conjunto de dados. Na parte superior do gráfico rápido do modelo, há uma pontuação do modelo. Um problema de classificação mostra uma pontuação na F1. Um problema de regressão tem uma pontuação de erro quadrático médio (MSE).
Ao criar um gráfico de modelo rápido, você seleciona um conjunto de dados que deseja avaliar e um rótulo de destino com o qual deseja comparar a importância do atributo. O Data Wrangler faz o seguinte:
+ Infere os tipos de dados para o rótulo de destino e cada atributo no conjunto de dados selecionado.
+ Determina o tipo de problema. Com base no número de valores distintos na coluna do rótulo, o Data Wrangler determina se esse é um tipo de problema de regressão ou classificação. O Data Wrangler define um limite categórico para 100. Se houver mais de 100 valores distintos na coluna do rótulo, o Data Wrangler o classifica como um problema de regressão; caso contrário, ele é classificado como um problema de classificação.
+ Pré-processa os atributos e os dados de rótulos para treinamento. O algoritmo usado necessita codificar os atributos em tipo vetorial e rótulos de codificação em tipo duplo.
+ Treina um algoritmo de floresta aleatório com 70% dos dados. O Spark's [RandomForestRegressor](https://spark.apache.org/docs/latest/ml-classification-regression.html#random-forest-regression)é usado para treinar um modelo para problemas de regressão. O [RandomForestClassifier](https://spark.apache.org/docs/latest/ml-classification-regression.html#random-forest-classifier)é usado para treinar um modelo para problemas de classificação.
+ Avalia um modelo de floresta aleatória com os 30% restantes dos dados. O Data Wrangler avalia modelos de classificação usando uma pontuação F1 e avalia modelos de regressão usando uma pontuação MSE.
+ Calcula a importância do atributo para cada atributo usando o método de importância de Gini.
A imagem a seguir mostra a interface de usuário do atributo de modelo rápido.
![\[Exemplo de interface de usuário do atributo de modelo rápido no console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/quick-model.png)
## Vazamento do destino
O vazamento de destino ocorre quando há dados em um conjunto de dados de treinamento de machine learning que estão fortemente correlacionados com o rótulo de destino, mas não estão disponíveis em dados do mundo real. Por exemplo, você pode ter uma coluna em seu conjunto de dados que serve como proxy para a coluna que você deseja prever com seu modelo.
Ao usar a análise **Vazamento do destino**, você especifica o seguinte:
+ **Destino**: esse é o atributo sobre o qual você deseja que seu modelo de ML seja capaz de fazer predições.
+ **Tipo de problema**: esse é o tipo de problema de ML no qual você está processando. O tipo de problema pode ser **classificação** ou **regressão.**
+ (Opcional) **Máximo de atributos**: esse é o número máximo de atributos a serem apresentados na visualização, que mostra os atributos classificados de acordo com o risco de serem vazamentos de destino.
Para classificação, a análise de vazamento destino usa a área sob o atributo de operação do receptor ou a curva AUC - ROC para cada coluna, até os **Recursos máximos**. Para regressão, ele usa um coeficiente de determinação ou métrica R2.
A curva AUC-ROC fornece uma métrica preditiva, calculada individualmente para cada coluna usando validação cruzada, em uma amostra de aproximadamente até 1000 linhas. Uma pontuação de 1 indica habilidades preditivas perfeitas, o que geralmente indica vazamento do destino. Uma pontuação de 0,5 ou menos indica que as informações na coluna não poderiam fornecer, por si só, nenhuma informação útil para prever o destino. Embora seja possível que uma coluna seja pouco informativa por si só, mas seja útil na previsão do destino quando usada em conjunto com outros atributos, uma pontuação baixa pode indicar que o atributo é redundante.
Por exemplo, a imagem a seguir mostra um relatório de vazamento destino para um problema de classificação de diabetes, ou seja, prever se uma pessoa tem diabetes ou não. Uma curva AUC - ROC é usada para calcular a capacidade preditiva de cinco atributos, e todos são determinados como protegidos contra vazamentos de destinos.
![\[Exemplo de relatório de vazamento de destinos no console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/target-leakage.png)
## Multicolinearidade
A multicolinearidade é uma circunstância em que duas ou mais variáveis preditoras estão relacionadas entre si. As variáveis preditoras são os atributos do seu conjunto de dados que você está usando para prever uma variável destino. Quando você tem multicolinearidade, as variáveis preditoras não são apenas preditivas da variável destino, mas também preditivas umas das outras.
Você pode usar o **Fator de inflação de variância (VIF)**, a **Análise de componentes principais (PCA)** ou a **seleção de atributos Lasso** como medidas para a multicolinearidade em seus dados. Para obter mais informações, consulte.
------
#### [ Variance Inflation Factor (VIF) ]
O Fator de inflação de variância (VIF) é uma medida de colinearidade entre pares de variáveis. O Data Wrangler retorna uma pontuação VIF como uma medida de quão estreitamente as variáveis estão relacionadas entre si. Uma pontuação de VIF é um número positivo que é maior ou igual a 1.
Uma pontuação de 1 significa que a variável não está correlacionada com as outras variáveis. Pontuações maiores que 1 indicam maior correlação.
Teoricamente, você pode ter uma pontuação de VIF com um valor infinito. O Data Wrangler reduz as pontuações mais altas para 50. Se você tiver uma pontuação de VIF maior que 50, o Data Wrangler define a pontuação como 50.
Você pode usar as seguintes diretrizes para interpretar suas pontuações de VIF:
+ Uma pontuação de VIF menor ou igual a 5 indica que as variáveis estão moderadamente correlacionadas com as outras variáveis.
+ Uma pontuação de VIF menor ou igual a 5 indica que as variáveis estão moderadamente correlacionadas com as outras variáveis.
------
#### [ Principle Component Analysis (PCA) ]
A Análise de Componentes Principais (PCA) mede a variação dos dados em diferentes direções no espaço de atributos. O espaço de atributos consiste em todas as variáveis preditoras que você usa para prever a variável destino em seu conjunto de dados.
Por exemplo, se você está tentando prever quem sobreviveu no *RMS Titanic* depois que ele atingiu um iceberg, seu espaço especial pode incluir a idade, o gênero e a tarifa que os passageiros pagaram.
A partir do espaço de atributos, o PCA gera uma lista ordenada de variações. Essas variações também são conhecidas como valores singulares. Os valores na lista de variâncias são maiores ou iguais a 0. Podemos usá-los para determinar quanta multicolinearidade existe em nossos dados.
Quando os números são aproximadamente uniformes, os dados têm pouquíssimas instâncias de multicolinearidade. Quando há muita variabilidade entre os valores, temos muitas instâncias de multicolinearidade. Antes de executar o PCA, o Data Wrangler normaliza cada atributo para ter uma média de 0 e um desvio padrão de 1.
**nota**
O PCA nessa circunstância também pode ser chamado de Decomposição de Valor Singular (SVD).
------
#### [ Lasso feature selection ]
A seleção de atributos do Lasso usa a técnica de regularização L1 para incluir apenas os atributos mais preditivos em seu conjunto de dados.
Tanto para classificação quanto para regressão, a técnica de regularização gera um coeficiente para cada atributo. O valor absoluto do coeficiente fornece uma pontuação de importância para o atributo. Uma pontuação de importância mais alta indica que é mais preditiva da variável-destino. Um método comum de seleção de atributos é utilizar todas os atributos que têm um coeficiente lasso não nulo.
------
## Detectar anomalias em dados de séries temporais
Você pode usar a visualização de detecção de anomalias para ver valores discrepantes em seus dados de séries temporais. Para entender o que determina uma anomalia, você precisa entender que decompomos a série temporal em um termo previsto e um termo de erro. Tratamos a sazonalidade e a tendência da série temporal como o termo previsto. Tratamos os resíduos como o termo de erro.
Para o termo de erro, você especifica um limite como o número de desvios padrão que o resíduo pode afastar da média para que seja considerado uma anomalia. Por exemplo, é possível especificar um limite como sendo 3 desvios padrão. Qualquer resíduo maior que 3 desvios padrão da média é uma anomalia.
Você pode usar o procedimento a seguir para realizar uma análise de **detecção de anomalias**.
1. Abra seu fluxo de dados do Data Wrangler.
1. No seu fluxo de dados, em **Tipos de dados**, escolha o **\$1** e selecione **Adicionar análise**.
1. Para **Tipo de análise**, escolha **Séries temporais**.
1. Para **Visualização**, escolha **Detecção de anomalias**.
1. Em **Limite de anomalia**, escolha o limite em que um valor é considerado uma anomalia.
1. Escolha **Visualizar** para gerar uma visualização prévia da análise.
1. Escolha **Adicionar** para adicionar a transformação ao fluxo de dados do Data Wrangler.
## Decomposição de tendências sazonais em dados de séries temporais
Você pode determinar se há sazonalidade em seus dados de séries temporais usando a visualização de Decomposição de tendências sazonais. Usamos o método STL (Decomposição de tendência sazonal usando LOESS) para realizar a decomposição. Decompomos a série temporal em seus componentes sazonais, de tendência e residuais. A tendência reflete a progressão a longo prazo da série. O componente sazonal é um sinal que se repete em um período de tempo. Depois de remover a tendência e os componentes sazonais da série temporal, você tem o resíduo.
Você pode usar o procedimento a seguir para realizar uma análise de decomposição de **tendência sazonal**.
1. Abra seu fluxo de dados do Data Wrangler.
1. No seu fluxo de dados, em **Tipos de dados**, escolha o **\$1** e selecione **Adicionar análise**.
1. Para **Tipo de análise**, escolha **Séries temporais**.
1. Para **Visualização**, escolha **Decomposição de tendências sazonais**.
1. Em **Limite de anomalia**, escolha o limite em que um valor é considerado uma anomalia.
1. Escolha **Visualizar** para gerar uma visualização prévia da análise.
1. Escolha **Adicionar** para adicionar a transformação ao fluxo de dados do Data Wrangler.
## Relatório de desvio
Você pode usar o relatório de desvio no Data Wrangler para descobrir possíveis desvios em seus dados. Para gerar um relatório de desvio, você deve especificar a coluna de destino, ou **Rótulo**, que você deseja prever e uma **Faceta**, ou a coluna que você deseja inspecionar quanto a desvios.
**Rótulo**: o atributo sobre o qual você deseja que um modelo faça predições. Por exemplo, se você estiver prevendo a conversão do cliente, poderá selecionar uma coluna contendo dados sobre se um cliente fez ou não um pedido. Você também deve especificar se esse atributo é um rótulo ou um limite. Se você especificar um rótulo, deverá especificar a aparência de um *resultado positivo* em seus dados. No exemplo de conversão do cliente, um resultado positivo pode ser 1 na coluna de pedidos, representando o resultado positivo de um cliente que fez um pedido nos últimos três meses. Se você especificar um limite, é necessário também especificar um limite inferior que define um resultado positivo. Por exemplo, se as colunas de pedidos do cliente contiverem o número de pedidos feitos no último ano, talvez você queira especificar 1.
**Faceta**: a coluna que você deseja inspecionar em busca de vieses. Por exemplo, se você está tentando prever a conversão de clientes, a sua faceta pode ser a idade do cliente. Você pode escolher essa faceta porque acredita que seus dados são tendenciosos para uma determinada faixa etária. Você deve identificar se a faceta é medida como um valor ou limite. Por exemplo, se você quiser inspecionar uma ou mais idades específicas, selecione **Valor** e especifique essas idades. Se você deseja analisar um grupo etário específico, você seleciona o **Limite** e especifica o limite de idades que deseja inspecionar.
Depois de selecionar seu atributo e rótulo, você seleciona os tipos de métricas de desvio que deseja calcular.
Para saber mais, consulte [Gerar relatórios de parcialidade nos dados de pré-treinamento](https://docs.aws.amazon.com/sagemaker/latest/dg/data-bias-reports.html).
## Criar visualizações personalizadas
Você pode adicionar uma análise ao seu fluxo do Data Wrangler para criar uma visualização personalizada. [Seu conjunto de dados, com todas as transformações que você aplicou, está disponível como Pandas. DataFrame](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.html) O Data Wrangler usa a variável `df` para armazenar o quadro de dados. Você acessa o quadro de dados chamando a variável.
Você deve fornecer a variável de saída, `chart`, para armazenar um gráfico de saída do [Altair](https://altair-viz.github.io/). Por exemplo, você pode usar o seguinte bloco de código para criar um histograma personalizado usando o conjunto de dados do Titanic:
```
import altair as alt
df = df.iloc[:30]
df = df.rename(columns={"Age": "value"})
df = df.assign(count=df.groupby('value').value.transform('count'))
df = df[["value", "count"]]
base = alt.Chart(df)
bar = base.mark_bar().encode(x=alt.X('value', bin=True, axis=None), y=alt.Y('count'))
rule = base.mark_rule(color='red').encode(
x='mean(value):Q',
size=alt.value(5))
chart = bar + rule
```
**Para criar uma visualização personalizada:**
1. Ao lado do nó que contém a transformação que você gostaria de visualizar, escolha o **\$1**.
1. Escolha **Adicionar análise**.
1. Em **Tipo de análise**, escolha **Visualização personalizada**.
1. Em **Nome da análise**, especifique um nome.
1. Insira seu código na caixa do código.
1. Escolha **Visualizar** para visualizar sua visualização.
1. Escolha **Salvar** para adicionar sua visualização.
![\[Exemplo de como adicionar sua visualização no console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/custom-visualization.png)
Se você não souber como usar o pacote de visualização Altair em Python, você pode usar trechos de código personalizados para ajudá-lo a começar.
Data Wrangler possui uma coleção pesquisável de trechos de código de visualização. Para usar um trecho de visualização, escolha **Pesquisar trechos de exemplo** e especifique uma consulta na barra de pesquisa.
O exemplo a seguir usa o trecho de código para um **gráfico de dispersão com bins**. Traça um histograma para 2 dimensões.
Os trechos de código possuem comentários para ajudar você a entender as alterações que precisa fazer no código. Normalmente, é necessário especificar os nomes das colunas do seu conjunto de dados no código.
```
import altair as alt
# Specify the number of top rows for plotting
rows_number = 1000
df = df.head(rows_number)
# You can also choose bottom rows or randomly sampled rows
# df = df.tail(rows_number)
# df = df.sample(rows_number)
chart = (
alt.Chart(df)
.mark_circle()
.encode(
# Specify the column names for binning and number of bins for X and Y axis
x=alt.X("col1:Q", bin=alt.Bin(maxbins=20)),
y=alt.Y("col2:Q", bin=alt.Bin(maxbins=20)),
size="count()",
)
)
# :Q specifies that label column has quantitative type.
# For more details on Altair typing refer to
# https://altair-viz.github.io/user_guide/encoding.html#encoding-data-types
```
# Reutilização de fluxos de dados para diferentes conjuntos de dados
Para fontes de dados do Amazon Simple Storage Service (Amazon S3), você pode criar e usar parâmetros. Um parâmetro é uma variável que você salvou no fluxo do Data Wrangler. Seu valor pode ser qualquer parte do caminho do Amazon S3 da fonte de dados. Use parâmetros para alterar rapidamente os dados que você está importando para um fluxo do Data Wrangler ou exportando para uma tarefa de processamento. Você também pode usar parâmetros para selecionar e importar um subconjunto específico dos seus dados.
Depois de criar um fluxo do Data Wrangler, você pode ter treinado um modelo com base nos dados que você transformou. Para conjuntos de dados que têm o mesmo esquema, você pode usar parâmetros para aplicar as mesmas transformações em um conjunto de dados diferente e treinar um modelo diferente. Você pode usar os novos conjuntos de dados para realizar inferências com seu modelo ou pode usá-los para retreinar seu modelo.
Em geral, os parâmetros têm os seguintes atributos:
+ Nome: O nome que você especifica para o parâmetro
+ Tipo: O tipo de valor que o parâmetro representa
+ Valor padrão: O valor do parâmetro quando você não especifica um novo valor
**nota**
Os parâmetros de data e hora têm um atributo de intervalo de tempo que eles usam como valor padrão.
O Data Wrangler usa chaves curvas, `{{}}`, para indicar que um parâmetro está sendo usado no caminho do Amazon S3. Por exemplo, você pode ter uma URL como `s3://amzn-s3-demo-bucket1/{{example_parameter_name}}/example-dataset.csv`.
Você cria um parâmetro ao editar a fonte de dados do Amazon S3 que você importou. Você pode definir qualquer parte do caminho do arquivo como um valor de parâmetro. É possível definir o valor do parâmetro como um valor ou um padrão. A seguir estão os tipos de valores de parâmetros disponíveis no fluxo do Data Wrangler:
+ Número
+ String
+ Padrão
+ Datetime
**nota**
Você não pode criar um parâmetro padrão ou um parâmetro de data e hora para o nome do bucket no caminho do Amazon S3.
Você deve definir um número como o valor padrão de um parâmetro numérico. Você pode alterar o valor do parâmetro para um número diferente ao editar um parâmetro ou ao iniciar um trabalho de processamento. Por exemplo, no caminho do S3, `s3://amzn-s3-demo-bucket/example-prefix/example-file-1.csv`, você pode criar um parâmetro numérico nomeado `number_parameter` no lugar de `1`. Seu caminho do S3 agora aparece como `s3://amzn-s3-demo-bucket/example-prefix/example-file-{{number_parameter}}.csv`. O caminho continua apontando para o `example-file-1.csv` conjunto de dados até que você altere o valor do parâmetro. Se você alterar o valor de `number_parameter` para, `2` o caminho será agora `s3://amzn-s3-demo-bucket/example-prefix/example-file-2.csv`. Você pode `example-file-2.csv` importar para o Data Wrangler se tiver carregado o arquivo para esse local do Amazon S3.
Um parâmetro de string armazena uma string como seu valor padrão. Por exemplo, no caminho do S3, `s3://amzn-s3-demo-bucket/example-prefix/example-file-1.csv`, você pode criar um parâmetro de string chamado `string_parameter` no lugar do nome do arquivo, `example-file-1.csv`. O caminho agora aparece como `s3://amzn-s3-demo-bucket/example-prefix/{{string_parameter}}`. Ele continua a coincidir `s3://amzn-s3-demo-bucket/example-prefix/example-file-1.csv` até que você altere o valor do parâmetro.
Em vez de especificar o nome do arquivo como um parâmetro de string, você pode criar um parâmetro de string usando todo o caminho do Amazon S3. Você pode especificar um conjunto de dados de qualquer local do Amazon S3 no parâmetro string.
Um parâmetro de padrão armazena uma string de expressão regular (Python REGEX) como seu valor padrão. É possível usar um parâmetro de padrão para importar vários arquivos de dados ao mesmo tempo. Para importar mais de um objeto por vez, especifique um valor de parâmetro que corresponda aos objetos do Amazon S3 que você está importando.
Você também pode criar um parâmetro de padrão para os seguintes conjuntos de dados:
+ s3://amzn-s3-demo-bucket1/example-prefix/example-file-1.csv
+ s3://amzn-s3-demo-bucket1/example-prefix/example-file-2.csv
+ s3://amzn-s3-demo-bucket1/example-prefix/example-file-10.csv
+ s3://amzn-s3-demo - bucket/example-prefix/example -file-0123.csv
Para `s3://amzn-s3-demo-bucket1/example-prefix/example-file-1.csv`, você pode criar um parâmetro padrão no lugar `1` de e definir o valor padrão do parâmetro como `\d+`. A string `\d+` REGEX corresponde a qualquer um ou mais dígitos decimais. Se você criar um parâmetro de padrão chamado `pattern_parameter`, seu caminho do S3 aparecerá como `s3://amzn-s3-demo-bucket1/example-prefix/example-file-{{pattern_parameter}}.csv`.
Você também pode usar parâmetros de padrão para combinar todos os objetos CSV em seu bucket. Para combinar todos os objetos em um bucket, crie um parâmetro de padrão com o valor padrão de `.*` e defina o caminho como `s3://amzn-s3-demo-bucket/{{pattern_parameter}}.csv`. O caractere `.*` corresponde a qualquer caractere de string no caminho.
O caminho `s3://amzn-s3-demo-bucket/{{pattern_parameter}}.csv` pode corresponder aos seguintes conjuntos de dados:
+ `example-file-1.csv`
+ `other-example-file.csv`
+ `example-file-a.csv`
Um parâmetro de data e hora armazena o formato com as seguintes informações:
+ Um formato para analisar strings dentro de um caminho do Amazon S3.
+ Um intervalo de tempo relativo para limitar os valores de data e hora correspondentes
Por exemplo, no caminho do arquivo Amazon S3, `s3://amzn-s3-demo-bucket/2020/01/01/example-dataset.csv`, 2020/01/01 representa um datetime no formato de `year/month/day`. Você pode definir o intervalo de tempo do parâmetro para um intervalo como `1 years` ou `24 hours`. Um intervalo de `1 years` corresponde a todos os caminhos do S3 com datas que estão entre a hora atual e a hora exatamente um ano antes da hora atual. A hora atual é a hora em que você começa a exportar as transformações feitas nos dados. Para obter mais informações sobre como exportar os dados, consulte [Exportar](data-wrangler-data-export.md). Se a data atual for 01/01/2022 e o intervalo de tempo for `1 years`, o caminho do S3 corresponderá a conjuntos de dados como os seguintes:
+ s3://amzn-s3-demo-bucket/2021/01/01/example-dataset.csv
+ s3://amzn-s3-demo-bucket/2021/06/30/example-dataset.csv
+ s3://amzn-s3-demo-bucket/2021/12/31/example-dataset.csv
Os valores de data e hora em um intervalo de tempo relativo mudam com o passar do tempo. Os caminhos do S3 que estão dentro do intervalo de tempo relativo também podem ser diferentes.
Para o caminho do arquivo Amazon S3, `s3://amzn-s3-demo-bucket1/20200101/example-dataset.csv`, `20220101` é um exemplo de um caminho que pode se tornar um parâmetro de data e hora.
Para visualizar uma tabela de todos os parâmetros que você criou no fluxo do Data Wrangler, escolha `\$1\$1\$1\$1` à direita da caixa de texto contendo o caminho do Amazon S3. Você pode editar ou excluir um parâmetro que você criou, caso não precise mais dele. Para editar ou excluir um parâmetro, escolha os ícones à direita do parâmetro.
**Importante**
Antes de excluir um parâmetro, verifique se você não o usou em nenhum lugar do fluxo do Data Wrangler. Parâmetros excluídos que ainda estão dentro do fluxo causam erros.
Você pode criar parâmetros para qualquer etapa do fluxo do Data Wrangler. Você pode editar ou excluir um parâmetro que criou. Se você estiver aplicando transformações em dados que não são mais relevantes para seu caso de uso, você pode modificar os valores dos parâmetros. A modificação dos valores dos parâmetros altera os dados que você está importando.
As seções a seguir apresentam mais exemplos e orientações gerais sobre o uso de parâmetros. Você pode usar as seções para entender os parâmetros que funcionam melhor para você.
**nota**
As seções a seguir contêm procedimentos que usam a interface do Data Wrangler para substituir os parâmetros e criar uma tarefa de processamento.
Você também pode substituir os parâmetros usando os procedimentos a seguir.
Para exportar seu fluxo do Data Wrangler e substituir o valor de um parâmetro, faça o seguinte:
Escolha o **\$1** próximo ao nó que você deseja separar.
Selecione **Exportar para**.
Escolha o local para onde você está exportando os dados.
Em `parameter_overrides`, especifique valores diferentes para os parâmetros que você criou.
Executar o caderno Jupyter.
## Aplicação de um fluxo do Data Wrangler a arquivos usando padrões
Você pode usar parâmetros para aplicar transformações em seu fluxo do Data Wrangler a arquivos diferentes que correspondam a um padrão no caminho URI do Amazon S3. Ele ajuda você a especificar os arquivos no bucket do S3 que você deseja transformar com alta especificidade. Por exemplo, você pode ter um conjunto de dados com o caminho `s3://amzn-s3-demo-bucket1/example-prefix-0/example-prefix-1/example-prefix-2/example-dataset.csv`. Conjuntos de dados diferentes nomeados `example-dataset.csv` são armazenados sob muitos prefixos de exemplo diferentes. Os prefixos também podem ser numerados sequencialmente. É possível criar padrões para os números no URI do Amazon S3. Os parâmetros de padrão usam REGEX para selecionar qualquer número de arquivos que correspondam ao padrão da expressão. A seguir estão os padrões REGEX que podem ser úteis:
+ `.*`: Corresponde a zero ou mais de qualquer caractere, exceto caracteres de nova linha
+ `.+`: Corresponde a um ou mais caracteres de qualquer caractere, excluindo caracteres de nova linha
+ `\d+`: Corresponde a um ou mais dígitos decimais
+ `\w+`: Corresponde a um ou mais caracteres alfanuméricos
+ `[abc-_]{2,4}`: Corresponde a uma string de dois, três ou quatro caracteres composta pelo conjunto de caracteres fornecido dentro de um conjunto de colchetes
+ `abc|def`: Corresponde a uma string ou outra. Por exemplo, a operação corresponde a `abc` ou `def`
Você pode substituir cada número nos caminhos a seguir por um único parâmetro que tenha um valor de `\d+`.
+ `s3://amzn-s3-demo-bucket1/example-prefix-3/example-prefix-4/example-prefix-5/example-dataset.csv`
+ `s3://amzn-s3-demo-bucket1/example-prefix-8/example-prefix-12/example-prefix-13/example-dataset.csv`
+ `s3://amzn-s3-demo-bucket1/example-prefix-4/example-prefix-9/example-prefix-137/example-dataset.csv`
O procedimento a seguir cria um parâmetro padrão para um conjunto de dados com o caminho `s3://amzn-s3-demo-bucket1/example-prefix-0/example-prefix-1/example-prefix-2/example-dataset.csv`.
Para criar um parâmetro de padrão, faça o seguinte:
1. Ao lado do conjunto de dados que você importou, escolha **Editar conjunto** de dados.
1. Destaque a `0` entrada `example-prefix-0`.
1. Especifique valores para os seguintes campos:
+ **Nome**: Um nome para o parâmetro
+ **Tipo**: **Padrão**
+ **Valor** : **\$1 d\$1** uma expressão regular que corresponde a um ou mais dígitos
1. Escolha **Criar**.
1. Substitua o caminho do URI `1` e o `2` no S3 pelo parâmetro. O caminho deve ter o seguinte formato: `s3://amzn-s3-demo-bucket1/example-prefix-{{example_parameter_name}}/example-prefix-{{example_parameter_name}}/example-prefix-{{example_parameter_name}}/example-dataset.csv`
A seguir está um procedimento geral para criar um parâmetro de padrão.
1. Navegue até o fluxo do Data Wrangler.
1. Ao lado do conjunto de dados que você importou, escolha **Editar conjunto** de dados.
1. Destaque a parte do URI que você está usando como valor do parâmetro padrão.
1. Escolha **Criar parâmetro personalizado**.
1. Especifique valores para os seguintes campos:
+ **Nome**: Um nome para o parâmetro
+ **Tipo**: **Padrão**
+ **Valor**: Uma expressão regular contendo o padrão que você gostaria de armazenar.
1. Escolha **Criar**.
## Aplicação de um fluxo do Data Wrangler a arquivos usando valores numéricos
Você pode usar parâmetros para aplicar transformações no fluxo do Data Wrangler a arquivos diferentes que tenham caminhos semelhantes. Por exemplo, você pode ter um conjunto de dados com o caminho `s3://amzn-s3-demo-bucket1/example-prefix-0/example-prefix-1/example-prefix-2/example-dataset.csv`.
Você pode ter as transformações do fluxo do Data Wrangler que você aplicou aos conjuntos de dados abaixo `example-prefix-1`. Talvez você queira aplicar as mesmas transformações às `example-dataset.csv` que se enquadram em `example-prefix-10` ou `example-prefix-20`.
Você pode criar um parâmetro que armazene o valor `1`. Se quiser aplicar as transformações a conjuntos de dados diferentes, você pode criar trabalhos de processamento que substituam o valor do parâmetro por um valor diferente. O parâmetro atua como um espaço reservado para você alterar quando quiser aplicar as transformações do fluxo do Data Wrangler aos novos dados. Você pode substituir o valor do parâmetro ao criar uma tarefa de processamento do Data Wrangler para aplicar as transformações no fluxo do Data Wrangler a diferentes conjuntos de dados.
Use o procedimento a seguir para criar um filtro de campo numérico para `s3://amzn-s3-demo-bucket1/example-prefix-0/example-prefix-1/example-prefix-2/example-dataset.csv`.
Para criar parâmetros para o caminho anterior do URI do S3, faça o seguinte:
1. Navegue até o fluxo do Data Wrangler.
1. Ao lado do conjunto de dados que você importou, escolha **Editar conjunto** de dados.
1. Destaque o número em um exemplo de prefixo de `example-prefix-number`.
1. Escolha **Criar parâmetro personalizado**.
1. Em **Nome**, digite um nome para o parâmetro.
1. Em **Tipo**, escolha **Inteiro**.
1. Em **Valor**, especifique o número.
1. Crie parâmetros para os números restantes repetindo o procedimento.
Depois de criar os parâmetros, aplique as transformações ao seu conjunto de dados e crie um nó de destino para elas. Para obter mais informações sobre nós de destino, consulte [Exportar](data-wrangler-data-export.md).
Use o procedimento a seguir para aplicar as transformações do fluxo do Data Wrangler em um intervalo de tempo diferente. Ele pressupõe que você tenha criado um nó de destino para as transformações em seu fluxo.
Para alterar o valor de um parâmetro numérico em uma tarefa de processamento do Data Wrangler, faça o seguinte:
1. No fluxo do Data Wrangler, escolha **Criar trabalho**
1. Selecione somente o nó de destino que contém as transformações no conjunto de dados contendo os parâmetros de data e hora.
1. Selecione **Configurar trabalho**.
1. Selecione **Parâmetros**.
1. Escolha o nome do parâmetro que você criou.
1. Modifique o valor do parâmetro.
1. Repita o procedimento para os outros parâmetros.
1. Escolha **Executar**.
## Aplicação de um fluxo do Data Wrangler a arquivos usando cadeias de caracteres
Você pode usar parâmetros para aplicar transformações no fluxo do Data Wrangler a arquivos diferentes que tenham caminhos semelhantes. Por exemplo, você pode ter um conjunto de dados com o caminho `s3://amzn-s3-demo-bucket1/example-prefix/example-dataset.csv`.
Você pode ter transformações do fluxo do Data Wrangler que você aplicou aos conjuntos de dados abaixo `example-prefix`. Talvez você queira aplicar as mesmas transformações `example-dataset.csv` abaixo de `another-example-prefix` ou `example-prefix-20`.
Você pode criar um parâmetro que armazene o valor `example-prefix`. Se quiser aplicar as transformações a conjuntos de dados diferentes, você pode criar trabalhos de processamento que substituam o valor do parâmetro por um valor diferente. O parâmetro atua como um espaço reservado para você alterar quando quiser aplicar as transformações do fluxo do Data Wrangler aos novos dados. Você pode substituir o valor do parâmetro ao criar uma tarefa de processamento do Data Wrangler para aplicar as transformações no fluxo do Data Wrangler a diferentes conjuntos de dados.
Use o procedimento a seguir para criar um parâmetro para `s3://amzn-s3-demo-bucket1/example-prefix/example-dataset.csv`.
Para criar um parâmetro para o caminho anterior do URI do S3, faça o seguinte:
1. Navegue até o fluxo do Data Wrangler.
1. Ao lado do conjunto de dados que você importou, escolha **Editar conjunto** de dados.
1. Destaque o prefixo de exemplo, `example-prefix`.
1. Escolha **Criar parâmetro personalizado**.
1. Em **Nome**, digite um nome para o parâmetro.
1. Para **Tipo**, escolha **String**.
1. Em **Valor**, especifique o prefixo.
Depois de criar o parâmetro, aplique as transformações ao seu conjunto de dados e crie um nó de destino para elas. Para obter mais informações sobre nós de destino, consulte [Exportar](data-wrangler-data-export.md).
Use o procedimento a seguir para aplicar as transformações do fluxo do Data Wrangler em um intervalo de tempo diferente. Ele pressupõe que você tenha criado um nó de destino para as transformações em seu fluxo.
Para alterar o valor de um parâmetro numérico em uma tarefa de processamento do Data Wrangler, faça o seguinte:
1. No fluxo do Data Wrangler, escolha **Criar trabalho**
1. Selecione somente o nó de destino que contém as transformações no conjunto de dados contendo os parâmetros de data e hora.
1. Selecione **Configurar trabalho**.
1. Selecione **Parâmetros**.
1. Escolha o nome do parâmetro que você criou.
1. Modifique o valor do parâmetro.
1. Repita o procedimento para os outros parâmetros.
1. Escolha **Executar**.
## Aplicando um fluxo do Data Wrangler a diferentes intervalos de data e hora
Use parâmetros de data e hora para aplicar transformações em seu fluxo do Data Wrangler em diferentes intervalos de tempo. Destaque a parte do URI do Amazon S3 que tem um carimbo de data/hora e crie um parâmetro para ela. Ao criar um parâmetro, você especifica um intervalo de tempo da hora atual até uma hora no passado. Por exemplo, você pode ter um URI do Amazon S3 que se parece com o seguinte: `s3://amzn-s3-demo-bucket1/example-prefix/2022/05/15/example-dataset.csv`. Você pode salvar `2022/05/15` como um parâmetro de data e hora. Se você especificar um ano como intervalo de tempo, o intervalo de tempo incluirá o momento em que você executa o trabalho de processamento contendo o parâmetro de data e hora e a hora de exatamente um ano atrás. Se o momento em que você estiver executando o trabalho de processamento for 6 de setembro de 2022 ou `2022/09/06`, os intervalos de tempo podem incluir o seguinte:
+ `s3://amzn-s3-demo-bucket1/example-prefix/2022/03/15/example-dataset.csv`
+ `s3://amzn-s3-demo-bucket1/example-prefix/2022/01/08/example-dataset.csv`
+ `s3://amzn-s3-demo-bucket1/example-prefix/2022/07/31/example-dataset.csv`
+ `s3://amzn-s3-demo-bucket1/example-prefix/2021/09/07/example-dataset.csv`
As transformações no fluxo do Data Wrangler se aplicam a todos os prefixos anteriores. Alterar o valor do parâmetro na tarefa de processamento não altera o valor do parâmetro no fluxo do Data Wrangler. Para aplicar as transformações aos conjuntos de dados em um intervalo de tempo diferente, faça o seguinte:
1. Crie um nó de destino contendo todas as transformações que gostaria de usar.
1. Crie uma tarefa do Data Wrangler.
1. Configure a tarefa para usar um intervalo de tempo diferente para o parâmetro. Alterar o valor do parâmetro na tarefa de processamento não altera o valor do parâmetro no fluxo do Data Wrangler.
Para obter mais informações sobre nós de destino e trabalhos do Data Wrangler, consulte [Exportar](data-wrangler-data-export.md).
O seguinte procedimento cria um parâmetro de data e hora para o caminho do Amazon S3: `s3://amzn-s3-demo-bucket1/example-prefix/2022/05/15/example-dataset.csv`.
Para criar um parâmetro de data e hora para o caminho anterior do URI do S3, faça o seguinte:
1. Navegue até o fluxo do Data Wrangler.
1. Ao lado do conjunto de dados que você importou, escolha **Editar conjunto** de dados.
1. Destaque a parte do URI que você está usando como valor do parâmetro datetime.
1. Escolha **Criar parâmetro personalizado**.
1. Em **Nome**, digite um nome para o parâmetro.
1. Em **Tipo**, escolha **Data e hora**.
**nota**
Por padrão, o Data Wrangler seleciona **Predefinido**, que fornece um menu suspenso para você selecionar um formato de data. No entanto, o formato de carimbo de data/hora que você está usando pode não estar disponível. Em vez de usar **Predefinido** como opção padrão, você pode escolher **Personalizado** e especificar o formato do carimbo de data/hora manualmente.
1. Para **Formato de data**, abra o menu suspenso depois de **Predefinido** e escolha. **yyyy/MM/dd** O formato, **yyyy/MM/dd,** corresponde ao year/month/day do timestamp.
1. Em **Fuso horário**, escolha um fuso horário.
**nota**
Os dados que você está analisando podem ter registros de data e hora em um fuso horário diferente do seu fuso horário. Verifique se o fuso horário selecionado corresponde ao fuso horário dos dados.
1. Em **Intervalo de tempo**, especifique o intervalo de tempo para o parâmetro.
1. (Opcional) Insira uma descrição para descrever como você está usando o parâmetro.
1. Escolha **Criar**.
Depois de criar os parâmetros de data e hora, aplique as transformações ao seu conjunto de dados e crie um nó de destino para elas. Para obter mais informações sobre nós de destino, consulte [Exportar](data-wrangler-data-export.md).
Use o procedimento a seguir para aplicar as transformações do fluxo do Data Wrangler em um intervalo de tempo diferente. Ele pressupõe que você tenha criado um nó de destino para as transformações em seu fluxo.
Para alterar o valor de um parâmetro de data e hora em uma tarefa de processamento do Data Wrangler, faça o seguinte:
1. No fluxo do Data Wrangler, escolha **Criar trabalho**
1. Selecione somente o nó de destino que contém as transformações no conjunto de dados contendo os parâmetros de data e hora.
1. Selecione **Configurar trabalho**.
1. Selecione **Parâmetros**.
1. Escolha o nome do parâmetro datetime que você criou.
1. Em **Intervalo de tempo**, altere o intervalo de tempo dos conjuntos de dados.
1. Escolha **Executar**.
# Exportar
No fluxo do Data Wrangler, você pode exportar algumas ou todas as transformações que você fez para seus pipelines de processamento de dados.
Um *fluxo do Data Wrangler* é a série de etapas de preparação de dados que você executou em seus dados. Na preparação de dados, você realiza uma ou mais transformações em seus dados. Cada transformação é feita usando uma etapa de transformação. O fluxo tem uma série de nós que representam a importação de seus dados e as transformações que você realizou. Para obter um exemplo de nós, consulte as imagens a seguir.
![\[Exemplo de fluxo de dados no console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/data-wrangler-destination-nodes-photo-0.png)
A imagem anterior mostra um fluxo do Data Wrangler com dois nós. O nó **Fonte - amostra** mostra a fonte de dados da qual você importou seus dados. O nó **Tipos de dados** indica que o Data Wrangler realizou uma transformação para converter o conjunto de dados em um formato utilizável.
Cada transformação que você adiciona ao fluxo do Data Wrangler aparece como um nó adicional. Para obter mais informações sobre as transformações que você pode adicionar, consulte [Transformar dados](data-wrangler-transform.md). A imagem a seguir mostra um fluxo do Data Wrangler que tem um nó **Renomear coluna** para alterar o nome de uma coluna em um conjunto de dados.
Você pode exportar suas transformações de dados para o seguinte:
+ Amazon S3
+ Pipelines
+ Loja de SageMaker recursos da Amazon
+ Código Python
**Importante**
Recomendamos que você use a política `AmazonSageMakerFullAccess` gerenciada do IAM para conceder AWS permissão para usar o Data Wrangler. Se você não usar a política gerenciada, poderá usar uma política do IAM que conceda ao Data Wrangler acesso a um bucket do Amazon S3. Para obter mais informações sobre a política, consulte [Segurança e permissões](data-wrangler-security.md).
Ao exportar seu fluxo de dados, você é cobrado pelos AWS recursos que usa. Você pode usar tags de alocação de custos para organizar e gerenciar os custos desses recursos. Você cria essas tags para seu perfil de usuário e o Data Wrangler as aplica automaticamente aos recursos usados para exportar o fluxo de dados. Para obter mais informações, consulte [Usar tags de alocação de custos](https://docs.aws.amazon.com//awsaccountbilling/latest/aboutv2/cost-alloc-tags.html).
## Exportar para o Amazon S3.
O Data Wrangler oferece a capacidade de exportar seus dados para um local dentro de um bucket do Amazon S3. Você pode especificar o local usando um dos seguintes métodos:
+ Nó de destino: Onde o Data Wrangler armazena os dados depois de processá-los.
+ Exportar para: Exporta os dados resultantes de uma transformação para o Amazon S3.
+ Exportar dados: Para conjuntos de dados pequenos, pode exportar rapidamente os dados que você transformou.
Use as seções a seguir para saber mais sobre cada um desses métodos.
------
#### [ Destination Node ]
Se você quiser enviar uma série de etapas de processamento de dados que você executou para o Amazon S3, crie um nó de destino. Um *nó de destino* informa ao Data Wrangler onde armazenar os dados depois de processá-los. Depois de criar um nó de destino, você cria um trabalho de processamento para gerar os dados. Um *trabalho de processamento* é um trabalho SageMaker de processamento da Amazon. Quando você usa um nó de destino, ele executa os recursos computacionais necessários para gerar os dados que você transformou no Amazon S3.
Você pode usar um nó de destino para exportar algumas das transformações ou todas as transformações que você fez em seu fluxo do Data Wrangler.
Você pode usar vários nós de destino para exportar diferentes transformações ou conjuntos de transformações. O exemplo a seguir mostra dois nós de destino em um único fluxo do Data Wrangler.
![\[Exemplo de fluxo de dados mostrando dois nós de destino no console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/data-wrangler-destination-nodes-photo-4.png)
Você pode usar o procedimento a seguir para criar nós de destino e exportar para um bucket do Amazon S3.
Para exportar seu fluxo de dados, você cria nós de destino e um trabalho do Data Wrangler para exportar os dados. A criação de uma tarefa do Data Wrangler inicia uma tarefa SageMaker de processamento para exportar seu fluxo. Você pode escolher os nós de destino que deseja exportar depois de criá-los.
**nota**
Você pode escolher **Criar tarefa** no fluxo do Data Wrangler para ver as instruções de uso de um trabalho de processamento.
Use o procedimento a seguir para criar nós de destino.
1. Escolha o **\$1** ao lado dos nós que representam as transformações que você deseja exportar.
1. Escolha **Adicionar destino**.
![\[Exemplo de fluxo de dados mostrando como adicionar um destino no console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/destination-nodes/destination-nodes-add-destination-0.png)
1. Escolha **Amazon S3**.
![\[Exemplo de fluxo de dados mostrando como adicionar um destino no console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/destination-nodes/destination-nodes-add-destination-S3-selected.png)
1. Especifique os seguintes campos:
+ **Nome do conjunto de dados**: o nome que você especifica para o conjunto de dados que você está exportando.
+ **Tipo de arquivo**: o formato do arquivo que você está exportando.
+ **Delimitador** (somente arquivos CSV e Parquet): o valor usado para separar outros valores.
+ **Compressão** (somente arquivos CSV e Parquet): o método de compactação usado para reduzir o tamanho do arquivo. É possível usar os seguintes métodos de compressão:
+ bzip2
+ desinflar
+ gzip
+ (Opcional) **Localização do Amazon S3**: a localização do S3 que você está usando para gerar os arquivos.
+ (Opcional) **Número de partições**: o número de conjuntos de dados que você está gravando como saída do trabalho de processamento.
+ (Opcional) **Partição por coluna**: grava todos os dados com o mesmo valor exclusivo da coluna.
+ (Opcional) **Parâmetros de inferência**: selecionar **Gerar artefato de inferência** aplica todas as transformações que você usou no fluxo do Data Wrangler aos dados que chegam ao seu pipeline de inferência. O modelo em seu pipeline faz predições sobre os dados transformados.
1. Escolha **Adicionar destino**.
Use o procedimento a seguir para criar um trabalho em processamento.
Crie um trabalho na página **Fluxo de dados** e escolha os nós de destino que você deseja exportar.
**nota**
Você pode escolher **Criar tarefa** no fluxo do Data Wrangler para ver as instruções para criar um trabalho de processamento.
1. Escolha **Criar trabalho**. A imagem a seguir mostra o painel que aparece depois que você seleciona **Criar tarefa**.
![\[Exemplo de painel de criação de trabalho de fluxo de dados no console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/destination-nodes/destination-nodes-create-job.png)
1. Em **Nome do trabalho**, especifique o nome do trabalho de exportação.
1. Selecione os nós de destino que deseja exportar.
1. (Opcional) Especifique um ARN de AWS KMS chave. Uma AWS KMS chave é uma chave criptográfica que você pode usar para proteger seus dados. Para obter mais informações sobre AWS KMS chaves, consulte [AWS Key Management Service](https://docs.aws.amazon.com//kms/latest/developerguide/overview.html).
1. (Opcional) Em **Parâmetros treinados**, escolha **Reajustar** se você tiver feito o seguinte:
+ Coletou amostras do seu conjunto de dados
+ Aplicou uma transformação que usa seus dados para criar uma nova coluna no conjunto de dados
Para obter mais informações sobre como reajustar as transformações que você fez em um conjunto de dados inteiro, consulte [Reajuste as transformações em todo o conjunto de dados e exporte-as](#data-wrangler-data-export-fit-transform).
**nota**
Para dados de imagem, o Data Wrangler exporta as transformações que você fez em todas as imagens. Reajustar as transformações não é aplicável ao seu caso de uso.
1. Selecione **Configurar trabalho**. A imagem a seguir mostra a página **Configurar tarefa**.
![\[Exemplo de página de configuração de trabalho de fluxo de dados no console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/destination-nodes/destination-nodes-configure-job.png)
1. (Opcional) Configure o trabalho do Data Wrangler. Você pode usar o seguinte exemplo de configuração:
+ **Configuração do trabalho**
+ **Configuração de memória Spark**
+ **Configuração de rede**
+ **Tags**
+ **Parâmetros**
+ **Programações de associados**
1. Escolha **Executar**.
------
#### [ Export to ]
Como alternativa ao uso de um nó de destino, você pode usar a opção **Exportar para exportar** seu fluxo do Data Wrangler para o Amazon S3 usando um caderno Jupyter. Você pode escolher qualquer nó de dados em seu fluxo do Data Wrangler e exportá-lo. A exportação do nó de dados exporta a transformação que o nó representa e as transformações que a precedem.
Use o procedimento a seguir para gerar um caderno Jupyter e executá-lo para exportar seu fluxo do Data Wrangler para o Amazon S3.
1. Escolha o **\$1** próximo ao nó que você deseja separar.
1. Selecione **Exportar para**.
1. Escolha o **Amazon S3 (via caderno Jupyter)**.
1. Executar o caderno Jupyter.
![\[Exemplo de fluxo de dados mostrando como exportar seu fluxo do Data Wrangler no console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/data-wrangler-destination-nodes-photo-export-to.png)
Quando você executa o notebook, ele exporta seu fluxo de dados (arquivo.flow) da Região da AWS mesma forma que o fluxo do Data Wrangler.
O caderno fornece opções que você pode usar para configurar o trabalho de processamento e os dados que ele gera.
**Importante**
Fornecemos configurações de trabalho para configurar a saída de seus dados. Para as opções de particionamento e memória do driver, é altamente recomendável que você não especifique uma configuração, a menos que já tenha conhecimento sobre elas.
Em **Configuração do trabalho**, você pode configurar o seguinte:
+ `output_content_type`: O tipo de conteúdo do arquivo de saída. Usa `CSV` como formato padrão, mas você pode especificar `Parquet`.
+ `delimiter`: O caractere usado para separar valores no conjunto de dados ao gravar em um arquivo CSV.
+ `compression`: Se definido, comprime o arquivo de saída. Usa gzip como formato de compactação padrão.
+ `num_partitions`: O número de partições ou arquivos que o Data Wrangler grava como saída.
+ `partition_by`: Os nomes das colunas que você usa para particionar a saída.
Para alterar o formato do arquivo de saída de CSV para Parquet, altere o valor de `"CSV"` para `"Parquet"`. Para o restante dos campos anteriores, remova o comentário das linhas que contêm os campos que você deseja especificar.
Em **(Opcional) Configurar a memória do driver do cluster Spark**, você pode configurar as propriedades do Spark para o trabalho, como a memória do driver do Spark, no dicionário `config`.
O seguinte mostra o dicionário `config`:
```
config = json.dumps({
"Classification": "spark-defaults",
"Properties": {
"spark.driver.memory": f"{driver_memory_in_mb}m",
}
})
```
Para aplicar a configuração à tarefa de processamento, remova o comentário das seguintes linhas:
```
# data_sources.append(ProcessingInput(
# source=config_s3_uri,
# destination="/opt/ml/processing/input/conf",
# input_name="spark-config",
# s3_data_type="S3Prefix",
# s3_input_mode="File",
# s3_data_distribution_type="FullyReplicated"
# ))
```
------
#### [ Export data ]
Se você tiver uma transformação em um pequeno conjunto de dados que deseja exportar rapidamente, poderá usar o método **Exportar dados**. Quando você começa a escolher **Exportar dados**, o Data Wrangler trabalha de forma síncrona para exportar os dados que você transformou para o Amazon S3. Você não pode usar o Data Wrangler até que ele termine de exportar seus dados ou cancele a operação.
Para obter informações sobre como usar o método **Exportar dados** em seu fluxo do Data Wrangler, consulte o procedimento a seguir.
Para usar o método **Exportar dados**:
1. Escolha um nó em seu fluxo do Data Wrangler abrindo-o (clicando duas vezes nele).
![\[Exemplo de fluxo de dados mostrando como exportar dados no console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/export-s3.png)
1. Configure como você deseja exportar os dados.
1. Escolha **Exportar dados**.
------
Quando você exporta seu fluxo de dados para um bucket do Amazon S3, o Data Wrangler armazena uma cópia do arquivo de fluxo no bucket do S3. Ele armazena o arquivo de fluxo sob o prefixo *data\$1wrangler\$1flows*. Se você usar o bucket padrão do Amazon S3 para armazenar seus arquivos de fluxo, ele usa a seguinte convenção de nomenclatura: `sagemaker-region-account number`. Por exemplo, se o número da sua conta for 111122223333 e você estiver usando o Studio Classic em us-east-1, seus conjuntos de dados importados serão armazenados em `sagemaker-us-east-1-111122223333`. Neste exemplo, seus arquivos.flow criados em us-east-1 são armazenados em `s3://sagemaker-region-account number/data_wrangler_flows/`.
## Exportar para o Pipelines
Quando quiser criar e implantar fluxos de trabalho de aprendizado de máquina (ML) em grande escala, você pode usar o Pipelines para criar fluxos de trabalho que gerenciam e implantam trabalhos de IA. SageMaker Com o Pipelines, você pode criar fluxos de trabalho que gerenciam suas tarefas de preparação de dados de SageMaker IA, treinamento de modelos e implantação de modelos. Você pode usar os algoritmos primários que a SageMaker IA oferece usando Pipelines. Para obter mais informações sobre pipelines, consulte [SageMaker Pipelines](https://docs.aws.amazon.com/sagemaker/latest/dg/pipelines.html).
Quando você exporta uma ou mais etapas do seu fluxo de dados para o Pipelines, o Data Wrangler cria um caderno Jupyter que você pode usar para definir, instanciar, executar e gerenciar um pipeline.
### Use um caderno Jupyter para criar um pipeline
Use o procedimento a seguir para criar um caderno Jupyter para exportar seu fluxo do Data Wrangler para o Pipelines.
Use o procedimento a seguir para gerar um caderno Jupyter e executá-lo para exportar seu fluxo do Data Wrangler para o Pipelines.
1. Escolha o **\$1** próximo ao nó que você deseja separar.
1. Selecione **Exportar para**.
1. Escolha **Pipelines (via caderno Jupyter)**.
1. Executar o caderno Jupyter.
![\[Exemplo de fluxo de dados mostrando como exportar seu fluxo do Data Wrangler no console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/data-wrangler-destination-nodes-photo-export-to.png)
Você pode usar o caderno Jupyter que o Data Wrangler produz para definir um pipeline. O pipeline inclui as etapas de processamento de dados que são definidas pelo fluxo do Data Wrangler.
Você pode adicionar etapas adicionais ao seu pipeline adicionando etapas à lista `steps` no código a seguir no caderno:
```
pipeline = Pipeline(
name=pipeline_name,
parameters=[instance_type, instance_count],
steps=[step_process], #Add more steps to this list to run in your Pipeline
)
```
Para obter mais informações sobre a definição de pipelines, consulte [Definir o SageMaker AI Pipeline](https://docs.aws.amazon.com/sagemaker/latest/dg/define-pipeline.html).
## Exportar para um endpoint de inferência
Use seu fluxo do Data Wrangler para processar dados no momento da inferência criando um pipeline de inferência serial de SageMaker IA a partir do seu fluxo do Data Wrangler. Um pipeline de inferência é uma série de etapas que resulta em um modelo treinado fazendo predições sobre novos dados. Um pipeline de inferência serial no Data Wrangler transforma os dados brutos e os fornece ao modelo de machine learning para uma predição. Você cria, executa e gerencia o pipeline de inferência por meio de um caderno Jupyter no Studio Classic. Para obter mais informações sobre o acesso ao caderno, consulte [Use um caderno Jupyter para criar um endpoint de inferência](#data-wrangler-inference-notebook).
No caderno, você pode treinar um modelo de machine learning ou especificar um que já tenha treinado. Você pode usar o Amazon SageMaker Autopilot ou XGBoost treinar o modelo usando os dados que você transformou em seu fluxo do Data Wrangler.
O pipeline fornece a capacidade de realizar inferências em lote ou em tempo real. Você também pode adicionar o fluxo do Data Wrangler ao SageMaker Model Registry. Para obter mais informações sobre modelos de host, consulte [Endpoints multimodelo](multi-model-endpoints.md).
**Importante**
Você não pode exportar seu fluxo do Data Wrangler para um endpoint de inferência se ele tiver as seguintes transformações:
Ingressar
concatenar
Agrupar por
Se você precisar usar as transformações anteriores para preparar seus dados, use o procedimento a seguir.
Crie um fluxo do Data Wrangler.
Aplique as transformações anteriores que não são compatíveis.
Exportar os dados para um bucket do Amazon S3.
Crie um fluxo de Data Wrangler separado.
Importe os dados que você exportou do fluxo anterior.
Aplique as transformações restantes.
Crie um pipeline de inferência serial usando o caderno Jupyter que fornecemos.
Para obter informações sobre como exportar dados para um bucket do Amazon S3, consulte [Exportar para o Amazon S3.](#data-wrangler-data-export-s3). Para obter informações sobre como abrir o caderno Jupyter usado para criar o pipeline de inferência serial, consulte [Use um caderno Jupyter para criar um endpoint de inferência](#data-wrangler-inference-notebook).
O Data Wrangler ignora as transformações que removem dados no momento da inferência. Por exemplo, o Data Wrangler ignora a transformação [Processamento de valores ausentes](data-wrangler-transform.md#data-wrangler-transform-handle-missing) se você usar a configuração **Drop missing**.
Se você reajustou as transformações em todo o seu conjunto de dados, as transformações são transferidas para seu pipeline de inferência. Por exemplo, se você usou o valor mediano para imputar valores ausentes, o valor médio do reajuste da transformação será aplicado às suas solicitações de inferência. Você pode reajustar as transformações do seu fluxo do Data Wrangler ao usar o caderno Jupyter ou ao exportar seus dados para um pipeline de inferência. Para informações sobre reajustar transformações, consulte [Reajuste as transformações em todo o conjunto de dados e exporte-as](#data-wrangler-data-export-fit-transform).
O pipeline de inferência serial é compatível com os seguintes tipos de dados para as cadeias de caracteres de entrada e saída: Cada tipo de dados tem um conjunto de requisitos.
**Tipos de dados compatíveis**
+ `text/csv`: o tipo de dados para cadeias de caracteres CSV
+ A string não pode ter um cabeçalho.
+ Os atributos usados para o pipeline de inferência devem estar na mesma ordem dos atributos no conjunto de dados de treinamento.
+ Deve haver um delimitador de vírgula entre os atributos.
+ Os registros devem ser delimitados por um caractere de nova linha.
Veja a seguir um exemplo de uma string CSV com formatação válida que você pode fornecer em uma solicitação de inferência.
```
abc,0.0,"Doe, John",12345\ndef,1.1,"Doe, Jane",67890
```
+ `application/json`: o tipo de dados para strings JSON
+ Os atributos usados no conjunto de dados para o pipeline de inferência devem estar na mesma ordem dos atributos no conjunto de dados de treinamento.
+ Os dados devem ter um esquema específico. Você define o esquema como um único objeto `instances` que tem um conjunto de `features`. Cada objeto `features` representa uma observação.
Veja a seguir um exemplo de uma string JSON formatada validamente que você pode fornecer em uma solicitação de inferência.
```
{
"instances": [
{
"features": ["abc", 0.0, "Doe, John", 12345]
},
{
"features": ["def", 1.1, "Doe, Jane", 67890]
}
]
}
```
### Use um caderno Jupyter para criar um endpoint de inferência
Use o procedimento a seguir para exportar seu fluxo do Data Wrangler para criar um pipeline de inferência.
Para criar um pipeline de inferência usando um caderno Jupyter, faça o seguinte:
1. Escolha o **\$1** próximo ao nó que você deseja separar.
1. Selecione **Exportar para**.
1. Escolha o **SageMaker AI Inference Pipeline (via Jupyter** Notebook).
1. Executar o caderno Jupyter.
Quando você executa o caderno Jupyter, ele cria um artefato de fluxo de inferência. Um artefato de fluxo de inferência é um arquivo de fluxo do Data Wrangler com metadados adicionais usados para criar o pipeline de inferência serial. O nó que você está exportando abrange todas as transformações dos nós anteriores.
**Importante**
O Data Wrangler precisa do artefato do fluxo de inferência para executar o pipeline de inferência. Você não pode usar seu próprio arquivo de fluxo como artefato. Você deve criá-lo usando o procedimento anterior.
## Exportar para código Python
Para exportar todas as etapas do fluxo de dados para um arquivo Python que você possa integrar manualmente a qualquer fluxo de trabalho de processamento de dados, use o procedimento a seguir.
Use o procedimento a seguir para gerar um caderno Jupyter e executá-lo para exportar seu fluxo do Data Wrangler para o código Python.
1. Escolha o **\$1** próximo ao nó que você deseja separar.
1. Selecione **Exportar para**.
1. Escolha **Python Code**.
1. Executar o caderno Jupyter.
![\[Exemplo de fluxo de dados mostrando como exportar seu fluxo do Data Wrangler no console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/data-wrangler-destination-nodes-photo-export-to.png)
Pode ser necessário configurar o script Python para que seja executado no seu pipeline. Por exemplo, se você estiver executando um ambiente Spark, certifique-se de executar o script em um ambiente que tenha permissão para acessar AWS recursos.
## Exportar para a Amazon SageMaker Feature Store
Você pode usar o Data Wrangler para exportar recursos que você criou para a Amazon SageMaker Feature Store. Um atributo é uma coluna no seu conjunto de dados. O Feature Store é uma loja centralizada para atributos e seus metadados associados. Você pode usar o Feature Store para criar, compartilhar e gerenciar dados selecionados para o desenvolvimento de machine learning (ML). Armazenamentos centralizados tornam seus dados mais detectáveis e reutilizáveis. Para obter mais informações sobre a Feature Store, consulte [Amazon SageMaker Feature Store](https://docs.aws.amazon.com/sagemaker/latest/dg/feature-store.html).
Um conceito central no Feature Store é um grupo de atributos. Um grupo de atributos é uma coleção de atributos, seus registros (observações) e metadados associados. É semelhante a uma tabela em um banco de dados.
Você pode usar o Data Wrangler para realizar uma destas ações:
+ Atualize um grupo de atributos existente com novos registros. Um registro é uma observação no conjunto de dados.
+ Crie um novo grupo de atributos a partir de um nó em seu fluxo do Data Wrangler. O Data Wrangler adiciona as observações de seus conjuntos de dados como registros em seu grupo de atributos.
Se você estiver atualizando um grupo de atributos existente, o esquema do seu conjunto de dados deverá corresponder ao esquema do grupo de atributos. Todos os registros no grupo de atributos são substituídos pelas observações em seu conjunto de dados.
Você pode usar um caderno Jupyter ou um nó de destino para atualizar seu grupo de atributos com as observações no conjunto de dados.
Se seus grupos de recursos com o formato de tabela Iceberg tiverem uma chave de criptografia de loja off-line personalizada, certifique-se de conceder ao IAM que você está usando para o trabalho do Amazon SageMaker Processing permissões para usá-lo. No mínimo, você deve conceder permissões para criptografar os dados que você está gravando no Amazon S3. Para conceder as permissões, dê à função do IAM a capacidade de usar [GenerateDataKey](https://docs.aws.amazon.com/kms/latest/APIReference/API_GenerateDataKey.html)o. Para obter mais informações sobre como conceder permissões aos papéis do IAM para usar AWS KMS chaves, consulte [https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html)
------
#### [ Destination Node ]
Se você quiser enviar uma série de etapas de processamento de dados que você executou para um grupo de atributos, você pode criar um nó de destino. Quando você cria e executa um nó de destino, o Data Wrangler atualiza um grupo de atributos com seus dados. Também é possível criar um novo grupo de atributos a partir da interface do nó de destino. Depois de criar um nó de destino, você cria um trabalho de processamento para gerar os dados. Um trabalho de processamento é um trabalho SageMaker de processamento da Amazon. Quando você está usando um nó de destino, ele executa os atributos computacionais necessários para gerar os dados que você transformou no grupo de atributos.
Você pode usar um nó de destino para exportar algumas das transformações ou todas as transformações que você fez em seu fluxo do Data Wrangler.
Use o procedimento a seguir para criar um nó de destino para atualizar um grupo de atributos com as observações do seu conjunto de dados.
Para atualizar um grupo de atributos usando um nó de destino, faça o seguinte:
**nota**
Você pode escolher **Criar tarefa** no fluxo do Data Wrangler para ver as instruções de uso de um trabalho de processamento para atualizar o grupo de atributos.
1. Escolha o símbolo **\$1** ao lado do nó que contém o conjunto de dados que você gostaria de exportar.
1. Em **Adicionar destino**, escolha **SageMaker AI Feature Store**.
![\[Exemplo de fluxo de dados mostrando como adicionar um destino no console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/feature-store-destination-node-selection.png)
1. Escolha (clique duas vezes) no grupo de atributos. O Data Wrangler verifica se o esquema do grupo de atributos corresponde ao esquema dos dados que você está usando para atualizar o grupo de atributos.
1. (Opcional) Selecione **Exportar para armazenamento offline somente** para grupos de atributos que tenham um armazenamento on-line e um armazenamento offline. Essa opção só atualiza o armazenamento offline com observações do seu conjunto de dados.
1. **Depois que o Data Wrangler validar o esquema do seu conjunto de dados, escolha Adicionar.**
Use o procedimento a seguir para criar um novo grupo de atributos com dados do conjunto de dados.
Você pode armazenar seu grupo de atributos por meio de uma das seguintes maneiras:
+ On-line: cache de baixa latência e alta disponibilidade para um grupo de atributos que fornece pesquisa de registros em tempo real. O armazenamento on-line permite acesso rápido ao valor mais recente de um registro em um grupo de atributos.
+ Off-line: armazena dados do seu grupo de atributos em um bucket do Amazon S3. Você pode armazenar seus dados offline quando não precisar de leituras de baixa latência (menos de um segundo). Você pode usar um armazenamento offline para atributos usados na exploração de dados, treinamento de modelos e inferência em lote.
+ Online e offline: armazena seus dados em um armazenamento on-line e em um armazenamento offline.
Para criar um grupo de atributos usando um nó de destino, faça o seguinte:
1. Escolha o símbolo **\$1** ao lado do nó que contém o conjunto de dados que você gostaria de exportar.
1. Em **Adicionar destino**, escolha **SageMaker AI Feature Store**.
1. Escolha **Criar grupo de atributos**.
1. Na caixa de diálogo a seguir, se seu conjunto de dados não tiver uma coluna de horário do evento, selecione **Criar coluna EventTime "”**.
1. Escolha **Próximo**.
1. Escolha **Copiar esquema JSON**. Ao criar um grupo de atributos, você cola o esquema nas definições de atributos.
1. Escolha **Criar**.
1. Em **Nome do grupo de atributos**, especifique um nome para seu grupo de atributos.
1. Em **Descrição (opcional)**, especifique uma descrição para tornar seu grupo de atributos mais detectável.
1. Para criar um grupo de atributos para um armazenamento on-line, faça o seguinte:
1. Selecione **Ativar armazenamento online**.
1. Para a **chave de criptografia da loja virtual**, especifique uma chave de criptografia AWS gerenciada ou uma chave de criptografia própria.
1. Para criar um grupo de atributos para um armazenamento offline, faça o seguinte:
1. Selecione **Ativar armazenamento offline**. Especifique valores para os seguintes campos:
+ **Nome do bucket do S3**: o nome do bucket do Amazon S3 que armazena o grupo de atributos.
+ (Opcional) **Nome do diretório do conjunto** de dados: O prefixo do Amazon S3 que você está usando para armazenar o grupo de atributos.
+ **ARN do perfil do IAM**: o perfil do IAM que tem acesso à Feature Store.
+ **Formato da tabela**: Formato da tabela de seu armazenamento offline. Você pode especificar **Glue** ou **Iceberg**. **Glue** é o formato padrão.
+ **Chave de criptografia do armazenamento offline**: Por padrão, o Feature Store usa uma chave do AWS Key Management Service gerenciada, mas você pode usar o campo para especificar sua própria chave.
1. Especifique valores para os seguintes campos:
+ Nome do **bucket do S3**: o nome do bucket que armazena o grupo de atributos.
+ **(Opcional) Nome do diretório do conjunto** de dados: O prefixo do Amazon S3 que você está usando para armazenar o grupo de atributos.
+ **ARN do perfil do IAM**: o perfil do IAM que tem acesso à Feature Store.
+ **Chave de criptografia do armazenamento offline**: Por padrão, o Feature Store usa uma chave do AWS gerenciada, mas você pode usar o campo para especificar sua própria chave.
1. Escolha **Continuar**.
1. Escolha **JSON**.
1. Remova os colchetes de posição na janela.
1. Cole o texto JSON da Etapa 6.
1. Escolha **Continuar**.
1. Em **RECORD IDENTIFIER FEATURE NAME**, escolha a coluna em seu conjunto de dados que tem identificadores exclusivos para cada registro em seu conjunto de dados.
1. Em **Nome do atributo no horário do evento**, escolha a coluna com os valores do timestamp.
1. Escolha **Continuar**.
1. (Opcional) Adicione etiquetas para tornar seu grupo de atributos mais detectável.
1. Escolha **Continuar**.
1. Escolha **Criar grupo de atributos**.
1. Volte para o fluxo do Data Wrangler e escolha o ícone de atualização ao lado da barra de pesquisa do **Grupo de atributos**.
**nota**
Se você já criou um nó de destino para um grupo de atributos em um fluxo, não poderá criar outro nó de destino para o mesmo grupo de atributos. Se você quiser criar outro nó de destino para o mesmo grupo de atributos, deverá criar outro arquivo de fluxo.
Use o procedimento a seguir para criar um trabalho Data Wrangler.
Crie um trabalho na página **Fluxo de dados** e escolha os nós de destino que você deseja exportar.
1. Escolha **Criar trabalho**. A imagem a seguir mostra o painel que aparece depois que você seleciona **Criar tarefa**.
1. Em **Nome do trabalho**, especifique o nome do trabalho de exportação.
1. Selecione os nós de destino que deseja exportar.
1. (Opcional) Para **Chave KMS de saída**, especifique um ARN, ID ou alias de uma chave. AWS KMS Uma chave do KMS é uma chave criptográfica. Você pode usar a chave para criptografar os dados de saída do trabalho. Para obter mais informações sobre AWS KMS chaves, consulte [AWS Key Management Service](https://docs.aws.amazon.com//kms/latest/developerguide/overview.html).
1. A imagem a seguir mostra a página **Configure trabalho** com a guia **Configuração do trabalho** aberta.
![\[Exemplo de página de criação de trabalho do fluxo de dados no console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/destination-nodes/destination-nodes-configure-job.png)
(Opcional) Em **Parâmetros treinados**, escolha **Reajustar** se você tiver feito o seguinte:
+ Coletou amostras do seu conjunto de dados
+ Aplicou uma transformação que usa seus dados para criar uma nova coluna no conjunto de dados
Para obter mais informações sobre como reajustar as transformações que você fez em um conjunto de dados inteiro, consulte [Reajuste as transformações em todo o conjunto de dados e exporte-as](#data-wrangler-data-export-fit-transform).
1. Selecione **Configurar trabalho**.
1. (Opcional) Configure o trabalho do Data Wrangler. Você pode usar o seguinte exemplo de configuração:
+ **Configuração do trabalho**
+ **Configuração de memória Spark**
+ **Configuração de rede**
+ **Tags**
+ **Parâmetros**
+ **Programações de associados**
1. Escolha **Executar**.
------
#### [ Jupyter notebook ]
Use o procedimento a seguir em um notebook Jupyter para exportar para a Amazon SageMaker Feature Store.
Use o procedimento a seguir para gerar um caderno Jupyter e executá-lo para exportar seu fluxo do Data Wrangler para o Feature Store.
1. Escolha o **\$1** próximo ao nó que você deseja separar.
1. Selecione **Exportar para**.
1. Escolha **Amazon SageMaker Feature Store (via Jupyter Notebook**).
1. Executar o caderno Jupyter.
![\[Exemplo de fluxo de dados mostrando como exportar seu fluxo do Data Wrangler no console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/data-wrangler-destination-nodes-photo-export-to.png)
A execução de um caderno Jupyter executa um trabalho do Data Wrangler. A execução de uma tarefa do Data Wrangler inicia uma tarefa de processamento de SageMaker IA. O trabalho de processamento insere o fluxo em um arquivo de atributos online e offline.
**Importante**
O perfil do IAM que você usa para executar esse caderno deve ter as seguintes políticas AWS gerenciadas anexadas: `AmazonSageMakerFullAccess` e `AmazonSageMakerFeatureStoreAccess`.
Você só precisa habilitar um arquivo de atributos online ou offline ao criar um grupo de atributos. Você também pode habilitar ambos. Para desativar a criação do armazenamento on-line, defina `EnableOnlineStore` como`False`:
```
# Online Store Configuration
online_store_config = {
"EnableOnlineStore": False
}
```
O caderno usa os nomes das colunas e os tipos do quadro de dados que você exporta para criar um esquema de grupo de atributos, que é usado para criar um grupo de atributos. Um grupo de atributos é um grupo de atributos definidos no arquivo de atributos para descrever um registro. O grupo de atributos define o esquema e os atributo contidos no grupo de atributos. Uma definição de grupo de atributos é composta por uma lista de atributos, um nome de atributo de identificador de registro, nome do atributo no horário do evento e configurações para seu armazenamento on-line e armazenamento offline.
Cada atributo em um grupo de atributos pode ter um dos seguintes tipos: *String*, *Fracionário* ou *Integral*. Se uma coluna em seu quadro de dados exportado não for um desses tipos, o padrão é `String`.
Veja a seguir um exemplo de um esquema de grupo de atributos:
```
column_schema = [
{
"name": "Height",
"type": "long"
},
{
"name": "Input",
"type": "string"
},
{
"name": "Output",
"type": "string"
},
{
"name": "Sum",
"type": "string"
},
{
"name": "Time",
"type": "string"
}
]
```
Além disso, você deve especificar um nome de identificador de registro e um nome do atributo no horário do evento:
+ O *nome do identificador de registro* é o nome do atributo cujo valor identifica de forma exclusiva um registro definido no arquivo de atributos. Somente o registro mais recente por valor de identificador é armazenado no armazenamento on-line. O nome do atributo do identificador de registro deve ser um dos nomes das definições do atributo.
+ O *Nome do atributo no horário do evento* é o nome do atributo que armazena o `EventTime` de um registro em um grupo de atributos. Um `EventTime` é um período no tempo em que ocorre um novo evento que corresponde à criação ou atualização de um registro em um atributo. Todos os registros no grupo de atributos devem ter um correspondente `EventTime`.
O caderno usa essas configurações para criar um grupo de atributos, processar seus dados em grande escala e, em seguida, ingerir os dados processados em seus repositórios de atributos online e offline. Para saber mais, consulte [Fontes de dados e ingestão](https://docs.aws.amazon.com/sagemaker/latest/dg/feature-store-ingest-data.html).
------
O caderno usa essas configurações para criar um grupo de atributos, processar seus dados em grande escala e, em seguida, ingerir os dados processados em seus repositórios de atributos online e offline. Para saber mais, consulte [Fontes de dados e ingestão](https://docs.aws.amazon.com/sagemaker/latest/dg/feature-store-ingest-data.html).
## Reajuste as transformações em todo o conjunto de dados e exporte-as
Quando você importa dados, o Data Wrangler usa uma amostra dos dados para aplicar as codificações. Por padrão, o Data Wrangler usa as primeiras 50.000 linhas como amostra, mas você pode importar todo o conjunto de dados ou usar um método de amostragem diferente. Para obter mais informações, consulte [Importar](data-wrangler-import.md).
As transformações a seguir usam seus dados para criar uma coluna no conjunto de dados:
+ [Codificar categórico](data-wrangler-transform.md#data-wrangler-transform-cat-encode)
+ [Caracterizar texto](data-wrangler-transform.md#data-wrangler-transform-featurize-text)
+ [Lidar com valores discrepantes](data-wrangler-transform.md#data-wrangler-transform-handle-outlier)
+ [Processamento de valores ausentes](data-wrangler-transform.md#data-wrangler-transform-handle-missing)
Se você usou a amostragem para importar seus dados, as transformações anteriores usarão somente os dados da amostra para criar a coluna. A transformação pode não ter usado todos os dados relevantes. Por exemplo, se você usar a transformação **Codificar Categórica**, pode ter havido uma categoria em todo o conjunto de dados que não estava presente na amostra.
Você pode usar um nó de destino ou um caderno Jupyter para reajustar as transformações em todo o conjunto de dados. Quando o Data Wrangler exporta as transformações no fluxo, ele cria uma SageMaker tarefa de processamento. Quando o trabalho de processamento é concluído, o Data Wrangler salva os seguintes arquivos no local padrão do Amazon S3 ou em um local do S3 que você especificar:
+ O arquivo de fluxo do Data Wrangler que especifica as transformações que são reajustadas ao conjunto de dados
+ O conjunto de dados com as transformações de reajuste aplicadas a ele
Você pode abrir um arquivo de fluxo do Data Wrangler no Data Wrangler e aplicar as transformações em um conjunto de dados diferente. Por exemplo, se você aplicou as transformações a um conjunto de dados de treinamento, pode abrir e usar o arquivo de fluxo do Data Wrangler para aplicar as transformações a um conjunto de dados usado para inferência.
Para obter informações sobre o uso de nós de destino para reajustar transformações e exportar, consulte as seguintes páginas:
+ [Exportar para o Amazon S3.](#data-wrangler-data-export-s3)
+ [Exportar para a Amazon SageMaker Feature Store](#data-wrangler-data-export-feature-store)
Use o procedimento a seguir para executar um caderno Jupyter para reajustar as transformações e exportar os dados.
Para executar um caderno Jupyter, reajustar as transformações e exportar seu fluxo do Data Wrangler, faça o seguinte:
1. Escolha o **\$1** próximo ao nó que você deseja separar.
1. Selecione **Exportar para**.
1. Escolha o local para o qual você está exportando os dados.
1. Para o objeto `refit_trained_params`, defina `refit` como `True`.
1. Para o campo `output_flow`, especifique o nome do arquivo de fluxo de saída com as transformações de reajuste.
1. Executar o caderno Jupyter.
## Crie um cronograma para processar automaticamente novos dados
Se você estiver processando dados periodicamente, poderá criar um cronograma para executar o trabalho de processamento automaticamente. Por exemplo, você pode criar uma programação que execute um trabalho de processamento automaticamente quando você obtiver novos dados. Para obter mais informações sobre esses processos, consulte [Exportar para o Amazon S3.](#data-wrangler-data-export-s3) e [Exportar para a Amazon SageMaker Feature Store](#data-wrangler-data-export-feature-store).
Ao criar um trabalho, você deve especificar um perfil do IAM que tenha permissões para criar o trabalho. Por padrão, o perfil do IAM que você usa para acessar o Data Wrangler é o `SageMakerExecutionRole`.
As permissões a seguir permitem que o Data Wrangler acesse EventBridge e execute trabalhos EventBridge de processamento:
+ Adicione a seguinte política AWS gerenciada à função de execução do Amazon SageMaker Studio Classic, que fornece ao Data Wrangler permissões de uso: EventBridge
```
arn:aws:iam::aws:policy/AmazonEventBridgeFullAccess
```
Para obter mais informações sobre a política, consulte [políticas AWS gerenciadas para EventBridge](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-use-identity-based.html#eb-full-access-policy).
+ Adicione a seguinte política à perfil do IAM que você especificou ao criar um trabalho no Data Wrangler:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "sagemaker:StartPipelineExecution",
"Resource": "arn:aws:sagemaker:us-east-1:111122223333:pipeline/data-wrangler-*"
}
]
}
```
------
Se você estiver usando a função padrão do IAM, você adiciona a política anterior à função de execução do Amazon SageMaker Studio Classic.
Adicione a seguinte política de confiança à função para permitir que você EventBridge a assuma.
```
{
"Effect": "Allow",
"Principal": {
"Service": "events.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
```
**Importante**
Quando você cria uma agenda, o Data Wrangler cria uma `eventRule` entrada. EventBridge Você incorre em cobranças pelas regras de eventos que você cria e pelas instâncias usadas para executar o trabalho de processamento.
Para obter informações sobre EventBridge preços, consulte [ EventBridge Preços da Amazon](https://aws.amazon.com/eventbridge/pricing/). Para obter informações sobre o processamento de preços de trabalhos, consulte [Amazon SageMaker Pricing](https://aws.amazon.com/sagemaker/pricing/).
É possível criar uma programação usando um dos seguintes métodos:
+ [Expressões CRON](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-create-rule-schedule.html)
**nota**
O Data Wrangler não é compatível com as seguintes expressões:
LW\$1
Abreviações para dias
Abreviações para meses
+ [Expressões RATE](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-create-rule-schedule.html#eb-rate-expressions)
+ Recorrente: defina um intervalo de hora em hora ou diário para executar o trabalho.
+ Horário específico: defina dias e horários específicos para executar o trabalho.
As seções a seguir fornecem procedimentos para criar empregos.
------
#### [ CRON ]
Use o procedimento a seguir para criar uma agenda com uma expressão CRON.
Para especificar um cronograma com uma expressão CRON, faça o seguinte:
1. Abra seu fluxo do Data Wrangler.
1. Escolha **Criar trabalho**.
1. (Opcional) Para a **chave KMS de saída**, especifique uma AWS KMS chave para configurar a saída da tarefa.
1. Escolha **Próximo, 2. Configurar o trabalho**.
1. Selecione **Associar agendas**.
1. Escolha **Criar uma nova programação**.
1. Em **Nome do agendamento**, especifique o nome do agendamento.
1. Em **Frequência de execução**, escolha **CRON.**
1. Especifique uma expressão CRON válida.
1. Escolha **Criar**.
1. (Opcional) Escolha **Adicionar outro agendamento** para executar o trabalho em um agendamento adicional.
**nota**
Você pode associar no máximo duas programações. Os horários são independentes e não se afetam, a menos que os horários se sobreponham.
1. Escolha uma das seguintes opções:
+ **Agende e execute agora**: Data Wrangler, o trabalho é executado imediatamente e, posteriormente, executado de acordo com os cronogramas.
+ **Somente agendamento**: Data Wrangler, o trabalho só é executado nas programações que você especificar.
1. Escolha **Executar**
------
#### [ RATE ]
Use o procedimento a seguir para criar uma programação com uma expressão RATE.
Para especificar uma programação com uma expressão RATE, faça o seguinte:
1. Abra seu fluxo do Data Wrangler.
1. Escolha **Criar trabalho**.
1. (Opcional) Para a **chave KMS de saída**, especifique uma AWS KMS chave para configurar a saída da tarefa.
1. Escolha **Próximo, 2. Configurar o trabalho**.
1. Selecione **Associar agendas**.
1. Escolha **Criar uma nova programação**.
1. Em **Nome do agendamento**, especifique o nome do agendamento.
1. Em **Frequência de execução**, escolha **Taxa**.
1. Em **Valor**, especifique um valor inteiro.
1. Em **Unidade**, selecione uma das seguintes opções:
+ **Minutos**
+ **Horas**
+ **Dias**
1. Escolha **Criar**.
1. (Opcional) Escolha **Adicionar outro agendamento** para executar o trabalho em um agendamento adicional.
**nota**
Você pode associar no máximo duas programações. Os horários são independentes e não se afetam, a menos que os horários se sobreponham.
1. Escolha uma das seguintes opções:
+ **Agende e execute agora**: Data Wrangler, o trabalho é executado imediatamente e, posteriormente, executado de acordo com os cronogramas.
+ **Somente agendamento**: Data Wrangler, o trabalho só é executado nas programações que você especificar.
1. Escolha **Executar**
------
#### [ Recurring ]
Use o procedimento a seguir para criar um cronograma que execute um trabalho de forma recorrente.
Para especificar um cronograma com uma expressão CRON, faça o seguinte:
1. Abra seu fluxo do Data Wrangler.
1. Escolha **Criar trabalho**.
1. (Opcional) Para a **chave KMS de saída**, especifique uma AWS KMS chave para configurar a saída da tarefa.
1. Escolha **Próximo, 2. Configurar o trabalho**.
1. Selecione **Associar agendas**.
1. Escolha **Criar uma nova programação**.
1. Em **Nome do agendamento**, especifique o nome do agendamento.
1. Em **Frequência de execução**, verifique se a opção **Recorrente** está selecionada por padrão.
1. Para **Cada x horas**, especifique a frequência horária com que o trabalho é executado durante o dia. Os valores válidos são números inteiros no intervalo inclusivo de **1** e **23**.
1. Para **Em dias**, escolha uma das seguintes opções:
+ **Todos os dias**
+ **Finais de semana**
+ **Dias da semana**
+ **Selecionar dias**
1. (Opcional) Se você selecionou **Selecionar dias**, escolha os dias da semana para executar o trabalho.
**nota**
A programação é reiniciada todos os dias. Se você agendar um trabalho para ser executado a cada cinco horas, ele será executado nos seguintes horários do dia:
00:00
05:00
10:00
15:00
20:00
1. Escolha **Criar**.
1. (Opcional) Escolha **Adicionar outro agendamento** para executar o trabalho em um agendamento adicional.
**nota**
Você pode associar no máximo duas programações. Os horários são independentes e não se afetam, a menos que os horários se sobreponham.
1. Escolha uma das seguintes opções:
+ **Agende e execute agora**: Data Wrangler, o trabalho é executado imediatamente e, posteriormente, executado de acordo com os cronogramas.
+ **Somente agendamento**: Data Wrangler, o trabalho só é executado nas programações que você especificar.
1. Escolha **Executar**
------
#### [ Specific time ]
Use o procedimento a seguir para criar uma programação que execute um trabalho em horários específicos.
Para especificar um cronograma com uma expressão CRON, faça o seguinte:
1. Abra seu fluxo do Data Wrangler.
1. Escolha **Criar trabalho**.
1. (Opcional) Para a **chave KMS de saída**, especifique uma AWS KMS chave para configurar a saída da tarefa.
1. Escolha **Próximo, 2. Configurar o trabalho**.
1. Selecione **Associar agendas**.
1. Escolha **Criar uma nova programação**.
1. Em **Nome do agendamento**, especifique o nome do agendamento.
1. Escolha **Criar**.
1. (Opcional) Escolha **Adicionar outro agendamento** para executar o trabalho em um agendamento adicional.
**nota**
Você pode associar no máximo duas programações. Os horários são independentes e não se afetam, a menos que os horários se sobreponham.
1. Escolha uma das seguintes opções:
+ **Agende e execute agora**: Data Wrangler, o trabalho é executado imediatamente e, posteriormente, executado de acordo com os cronogramas.
+ **Somente agendamento**: Data Wrangler, o trabalho só é executado nas programações que você especificar.
1. Escolha **Executar**
------
Você pode usar o Amazon SageMaker Studio Classic para ver os trabalhos que estão programados para execução. Seus trabalhos de processamento são executados dentro do Pipelines. Cada trabalho de processamento tem seu próprio pipeline. Ele é executado como uma etapa de processamento dentro do pipeline. Você pode ver as agendas que você criou em um funil. Para obter informações sobre como visualizar um pipeline, consulte [Visualizar os detalhes de um pipeline](pipelines-studio-list.md).
Use o procedimento a seguir para visualizar os trabalhos que você programou.
Para obter os trabalhos que você programou, faça o seguinte:
1. Abra o Amazon SageMaker Studio Classic.
1. Abra o Pipelines
1. Veja os pipelines dos trabalhos que você criou.
O pipeline que executa o trabalho usa o nome do trabalho como prefixo. Por exemplo, se você criou um trabalho chamado `housing-data-feature-enginnering`, o nome do pipeline é `data-wrangler-housing-data-feature-engineering`.
1. Escolha o pipeline que contém seu trabalho.
1. Visualize o status dos pipelines. Pipelines com **status** de **Bem-sucedido** executaram o trabalho de processamento com êxito.
Para interromper a execução do trabalho de processamento, faça o seguinte:
Para interromper a execução de um trabalho de processamento, exclua a regra de evento que especifica a programação. A exclusão de uma regra de evento interrompe a execução de todos os trabalhos associados à programação. Para obter informações sobre como excluir uma regra, consulte Como [desativar ou excluir uma regra da Amazon](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-delete-rule.html). EventBridge
Você também pode interromper e excluir os pipelines associados aos agendamentos. Para obter informações sobre como interromper um pipeline, consulte [StopPipelineExecution](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StopPipelineExecution.html). Para obter informações sobre como excluir um pipeline, consulte [DeletePipeline](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeletePipeline.html#API_DeletePipeline_RequestSyntax).
# Use um widget interativo de preparação de dados em um notebook Amazon SageMaker Studio Classic para obter insights de dados
Use o widget de preparação de dados Data Wrangler para interagir com seus dados, obter visualizações, explorar insights acionáveis e corrigir problemas de qualidade de dados.
Você pode acessar o widget de preparação de dados em um notebook Amazon SageMaker Studio Classic. Para cada coluna, o widget cria uma visualização que ajuda você a entender melhor sua distribuição. Se uma coluna tiver problemas de qualidade de dados, um aviso será exibido em seu cabeçalho.
Para ver os problemas de qualidade dos dados, selecione o cabeçalho da coluna que mostra o aviso. Você pode usar as informações obtidas dos insights e das visualizações para aplicar as transformações integradas do widget e ajudá-lo a corrigir os problemas.
Por exemplo, o widget pode detectar que você tem uma coluna com apenas um valor exclusivo e mostrar um aviso. O aviso fornece a opção de remover a coluna do conjunto de dados.
## Conceitos básicos com execução de widget
Use as seguintes informações para ajudá-lo a começar a executar um caderno:
Abra um caderno no Amazon SageMaker Studio Classic. Para obter informações sobre como abrir um caderno, consulte [Crie ou abra um notebook Amazon SageMaker Studio Classic](notebooks-create-open.md).
**Importante**
Para executar o widget, o caderno deve usar uma das seguintes imagens:
Python 3 (Ciência de dados) com Python 3.7
Python 3 (Ciência de dados 2.0) com Python 3.8
Python 3 (Ciência de dados 3.0) com Python 3.10
SparkAnalytics 1,0
SparkAnalytics 2.0
Para obter mais informações sobre imagens, consulte [SageMaker Imagens da Amazon disponíveis para uso com notebooks Studio Classic](notebooks-available-images.md).
Use o código a seguir para importar o widget de preparação de dados e os pandas. O widget usa dataframes pandas para analisar seus dados.
```
import pandas as pd
import sagemaker_datawrangler
```
O código de exemplo a seguir carrega um arquivo no quadro de dados chamado `df`.
```
df = pd.read_csv("example-dataset.csv")
```
Você pode usar um conjunto de dados em qualquer formato que possa ser carregado como um objeto de dataframe pandas. Para obter mais informações sobre formatos de pandas, consulte [Ferramentas de E/S (texto, CSV HDF5,...).](https://pandas.pydata.org/pandas-docs/stable/user_guide/io.html)
A célula a seguir executa a variável `df` para iniciar o widget.
```
df
```
A parte superior do dataframe apresenta as seguintes opções:
+ **Exibir a tabela de pandas**: alterna entre a visualização interativa e uma tabela de pandas.
+ **Use todas as linhas do seu conjunto de dados para calcular os insights. Usar todo o conjunto de dados pode aumentar o tempo necessário para gerar os insights.** : Se você não selecionar a opção, o Data Wrangler calcula os insights das primeiras 10.000 linhas do conjunto de dados.
O quadro de dados mostra as primeiras 1000 linhas do conjunto de dados. Cada cabeçalho de coluna tem um gráfico de barras empilhadas que mostra as características da coluna. Ele mostra a proporção de valores válidos, valores inválidos e valores ausentes. Você pode passar o mouse sobre as diferentes partes do gráfico de barras empilhadas para obter as porcentagens calculadas.
Cada coluna tem uma visualização no cabeçalho. Veja a seguir os tipos de visualizações que as colunas podem ter:
+ Categórico: Gráfico de barras
+ Numérico: Histograma
+ Data e hora: Gráfico de barras
+ Texto: Gráfico de barras
Para cada visualização, o widget de preparação de dados destaca os valores discrepantes em laranja.
Quando você escolhe uma coluna, ela abre um painel lateral. O painel lateral mostra a guia **Insights**. O painel fornece uma contagem para os seguintes tipos de valores:
+ Valores inválidos: Valores cujo tipo não corresponde ao tipo de coluna.
+ Valores ausentes: Valores que estão ausentes, como `NaN` ou `None`.
+ Valores válidos: Valores que não estão ausentes nem são inválidos.
Para colunas numéricas, a guia **Insights** mostra as seguintes estatísticas resumidas:
+ Mínimo: O menor valor.
+ Máximo: O maior valor.
+ Média: A média dos valores.
+ Modo: O valor que aparece com mais frequência.
+ Desvio padrão: O desvio padrão dos valores.
Para colunas categóricas, a guia **Insights** mostra as seguintes estatísticas resumidas:
+ Valores exclusivos: O número de valores exclusivos na coluna.
+ Top: O valor que aparece com mais frequência.
As colunas que têm ícones de aviso em seus cabeçalhos têm problemas de qualidade de dados. A escolha de uma coluna abre uma guia **Qualidade de dados** que você pode usar para encontrar transformações que ajudem a corrigir o problema. Um aviso apresenta um dos seguintes níveis de severidade:
+ Baixo: Problemas que podem não afetar sua análise, mas podem ser úteis para serem corrigidos.
+ Médio: Problemas que provavelmente afetarão sua análise, mas provavelmente não são essenciais para serem corrigidos.
+ Alto: Problemas graves que recomendamos que sejam corrigidos.
**nota**
O widget classifica a coluna para mostrar os valores que têm problemas de qualidade de dados na parte superior do quadro de dados. Também destaca os valores que estão causando os problemas. A cor do destaque corresponde ao nível de severidade.
Em **TRANSFORMAÇÕES SUGERIDAS**, você pode escolher uma transformação para corrigir o problema de qualidade dos dados. O widget pode oferecer várias transformações que podem resolver o problema. Ele pode oferecer recomendações para as transformações mais adequadas ao problema. Você pode mover o cursor sobre a transformação para obter mais informações sobre ela.
Para aplicar uma transformação ao conjunto de dados, escolha **Aplicar e exportar código**. A transformação modifica o conjunto de dados e atualiza a visualização com valores modificados. O código para a transformação aparece na célula a seguir do caderno. Se você aplicar transformações adicionais ao conjunto de dados, o widget anexará as transformações à célula. Você pode usar o código gerado pelo widget para fazer o seguinte:
+ Personalize-o para melhor atender às suas necessidades.
+ Use-o em seus próprios fluxos de trabalho.
Você pode reproduzir todas as transformações que você fez executando novamente todas as células no caderno.
O widget pode fornecer informações e avisos para a coluna de destino. A coluna de destino é a coluna que você está tentando prever. Use o procedimento a seguir para obter insights da coluna de destino.
Para obter insights da coluna de destino, faça o seguinte:
1. Escolha a coluna que você está usando como coluna de destino.
1. Escolha **Selecionar como coluna de destino**.
1. Escolha o tipo de problema. Os insights e avisos do widget são personalizados de acordo com os tipos de problemas. Os tipos de problemas são os seguintes:
+ **Classificação**: A coluna de destino tem dados categóricos.
+ **Regressão**: A coluna de destino tem dados numéricos.
1. Escolha **Executar**.
1. (Opcional) Em **Insights da coluna de destino**, escolha uma das transformações sugeridas.
## Referência para os insights e transformações no widget
Para colunas de atributos (colunas que não são a coluna de destino), você pode obter os seguintes insights para avisá-lo sobre problemas com seu conjunto de dados:
+ **Valores ausentes**: A coluna tem valores ausentes `None`, como `NaN` (não é um número) ou `NaT` (não é um carimbo de data/hora). Muitos algoritmos de machine learning não é compatível comm valores ausentes nos dados de entrada. Preenchê-los ou eliminar as linhas com dados ausentes é, portanto, uma etapa crucial de preparação de dados. Se o aviso de valores ausentes for exibido, é possível usar uma das seguintes transformações para corrigir o problema:
+ **Eliminar linhas ausentes**: Elimina linhas com valores ausentes. Recomendamos eliminar as linhas quando a porcentagem de linhas com dados ausentes for pequena e a imputação dos valores ausentes não for apropriada.
+ **Substituir por um novo valor**: Substitui os valores textuais ausentes por `Other`. Você pode mudar `Other` para um valor diferente no código de saída. Substitui os valores numéricos ausentes por 0.
+ **Substituir pela média**: Substitui os valores faltantes pela média da coluna.
+ **Substituir pela média**: Substitui os valores faltantes pela média da coluna.
+ **Eliminar coluna**: Elimina a coluna com valores ausentes do conjunto de dados. Recomendamos descartar a coluna inteira quando houver uma alta porcentagem de linhas com dados ausentes.
+ **Valores faltantes disfarçados**: A coluna tem valores faltantes disfarçados. Um valor ausente disfarçado é um valor que não está explicitamente codificado como um valor ausente. Por exemplo, em vez de usar `NaN` a para indicar um valor ausente, o valor pode ser `Placeholder`. Você pode usar uma das seguintes transformações para lidar com os valores ausentes:
+ **Eliminar linhas ausentes**: Elimina linhas com valores ausentes
+ **Substituir por um novo valor**: Substitui os valores textuais ausentes por `Other`. Você pode mudar `Other` para um valor diferente no código de saída. Substitui os valores numéricos ausentes por 0.
+ **Coluna constante**: A coluna tem apenas um valor. Portanto, não tem poder preditivo. É altamente recomendável usar a transformação **Eliminar coluna** para remover a coluna do conjunto de dados.
+ **Coluna de ID**: A coluna não tem valores repetidos. Todos os valores na coluna são exclusivos. Elas podem ser uma IDs ou duas chaves de banco de dados. Sem informações adicionais, a coluna não tem poder preditivo. É altamente recomendável usar a transformação **Eliminar coluna** para remover a coluna do conjunto de dados.
+ **Alta cardinalidade**: A coluna tem uma alta porcentagem de valores exclusivos. A alta cardinalidade limita o poder preditivo das colunas categóricas. Examine a importância da coluna em sua análise e considere usar a transformação **Eliminar coluna** para eliminá-la.
Para a coluna de destino, você pode obter os seguintes insights para avisá-lo sobre problemas com seu conjunto de dados: Você pode usar a transformação sugerida fornecida com o aviso para corrigir o problema.
+ **Tipos de dados mistos no alvo (regressão)**: Há alguns valores não numéricos na coluna de destino. Pode haver erros na entrada de dados. Recomendamos remover as linhas que têm valores que não podem ser convertidos.
+ **Rótulo frequente**: Certos valores na coluna de destino aparecem com mais frequência do que o normal no contexto da regressão. Pode haver um erro na coleta ou processamento de dados. Uma categoria que aparece com frequência pode indicar que o valor é usado como valor padrão ou que é um espaço reservado para valores ausentes. Recomendamos usar a transformação **Substituir por um novo valor** para substituir os valores ausentes por `Other`.
+ **Poucas instâncias por classe**: A coluna de destino tem categorias que raramente aparecem. Algumas das categorias não têm linhas suficientes para que a coluna de destino seja útil. Você pode usar uma das seguintes transformações:
+ **Derrube um alvo raro**: Derruba valores únicos com menos de dez observações. Por exemplo, descarta o valor `cat` se ele aparecer nove vezes na coluna.
+ **Substitua o alvo raro**: substitui as categorias que raramente aparecem no conjunto de dados pelo valor. `Other`
+ **Classes muito desequilibradas (classificação multiclasse)**: Há categorias no conjunto de dados que aparecem com muito mais frequência do que as outras categorias. O desequilíbrio de classes pode afetar a precisão da predição. Para obter as predições mais precisas possíveis, recomendamos atualizar o conjunto de dados com linhas que tenham as categorias que atualmente aparecem com menos frequência.
+ **Grande classes/too quantidade de classes** — Há um grande número de classes na coluna de destino. Ter muitas aulas pode resultar em tempos de treinamento mais longos ou em baixa qualidade preditiva. Recomendamos seguir um destes procedimentos:
+ Agrupando algumas das categorias em sua própria categoria. Por exemplo, se seis categorias estiverem intimamente relacionadas, recomendamos usar uma única categoria para elas.
+ Usando um algoritmo de ML que seja resiliente a várias categorias.
# Segurança e permissões
Quando você consulta dados do Athena ou do Amazon Redshift, o conjunto de dados consultado é automaticamente armazenado no bucket AI S3 SageMaker padrão para a região na qual você está usando AWS o Studio Classic. *Além disso, quando você exporta um notebook Jupyter do Amazon SageMaker Data Wrangler e o executa, seus fluxos de dados, ou arquivos.flow, são salvos no mesmo bucket padrão, sob o prefixo data\$1wrangler\$1flows.*
Para necessidades de segurança de alto nível, você pode configurar uma política de bucket que restrinja as AWS funções que têm acesso a esse bucket SageMaker AI S3 padrão. Use a seção a seguir para adicionar esse tipo de política a um bucket do S3. Para seguir as instruções nesta página, use o AWS Command Line Interface (AWS CLI). Para saber como, consulte Como [configurar a AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) no Guia do usuário do IAM.
Além disso, você precisa conceder permissões a cada perfil do IAM que usa o Data Wrangler para acessar os recursos necessários. Se não precisar de permissões granulares para o perfil do IAM usado para acessar o Data Wrangler, poderá adicionar a política gerenciada do IAM, [https://console.aws.amazon.com/iam/home?#/policies/arn:aws:iam::aws:policy/AmazonSageMakerFullAccess](https://console.aws.amazon.com/iam/home?#/policies/arn:aws:iam::aws:policy/AmazonSageMakerFullAccess), a um perfil do IAM que você usa para criar seu usuário do Studio Classic. Esta política concede a você permissão total para usar o Data Wrangler. Se você precisar de permissões mais granulares, consulte a seção [Conceder permissão a um perfil do IAM para usar o Data Wrangler](#data-wrangler-security-iam-policy).
## Adicione uma política de bucket para restringir o acesso aos conjuntos de dados importados para o Data Wrangler
Você pode adicionar uma política ao bucket do S3 que contém seus recursos do Data Wrangler usando uma política de bucket do Amazon S3. Os recursos que o Data Wrangler carrega para seu bucket SageMaker AI S3 padrão na AWS região em que você está usando o Studio Classic incluem o seguinte:
+ Resultados consultados do Amazon Redshift. Eles são armazenados sob o prefixo *redshift/*.
+ Resultados consultados de Athena. Eles são armazenados sob o prefixo *redshift/*.
+ Os arquivos.flow são enviados para o Amazon S3 quando você executa um caderno Jupyter exportado produzido pelo Data Wrangler. Eles são armazenados sob o prefixo *data\$1wrangler\$1flows/*.
Use o procedimento a seguir para criar uma política de bucket do S3 que você pode adicionar para restringir o acesso do perfil do IAM a esse bucket. Para saber como adicionar uma política a um bucket do S3, consulte [Como adicionar uma política de bucket usando o console do S3?](https://docs.aws.amazon.com/AmazonS3/latest/user-guide/add-bucket-policy.html).
**Para configurar uma política de bucket no bucket do S3 que armazena seus recursos do Data Wrangler:**
1. Configure uma ou mais funções do IAM que você deseja acessar o Data Wrangler.
1. Abra um prompt de comando ou shell. Para cada função que você criar, *role-name* substitua pelo nome da função e execute o seguinte:
```
$ aws iam get-role --role-name role-name
```
Na resposta, você vê uma string `RoleId` que começa com`AROA`. Copie essa string.
1. Adicione a política a seguir ao bucket padrão de SageMaker IA na AWS região em que você está usando o Data Wrangler. *region*Substitua pela AWS região na qual o bucket está localizado e *account-id* pelo ID AWS da sua conta. Substitua `userId` s *AROAEXAMPLEID* começando pela IDs de qualquer AWS função para a qual você deseja conceder permissão para usar o Data Wrangler.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Principal": "*",
"Action": "s3:*",
"Resource": [
"arn:aws:s3:::sagemaker-us-east-1-111122223333/data_wrangler_flows/",
"arn:aws:s3:::sagemaker-us-east-1-111122223333/data_wrangler_flows/*",
"arn:aws:s3:::sagemaker-us-east-1-111122223333/athena",
"arn:aws:s3:::sagemaker-us-east-1-111122223333/athena/*",
"arn:aws:s3:::sagemaker-us-east-1-111122223333/redshift",
"arn:aws:s3:::sagemaker-us-east-1-111122223333/redshift/*"
],
"Condition": {
"StringNotLike": {
"aws:userId": [
"AROAEXAMPLEID_1:*",
"AROAEXAMPLEID_2:*"
]
}
}
}
]
}
```
------
## Crie uma lista de permissões para o Data Wrangler
Sempre que um usuário começa a executar o Data Wrangler a partir da interface de usuário do Amazon SageMaker Studio Classic, ele faz uma chamada para a interface de programação de aplicativos (API) de SageMaker IA para criar um aplicativo Data Wrangler.
Sua organização pode não fornecer aos usuários permissões para fazer essas chamadas de API por padrão. Para fornecer permissões, você deve criar e anexar uma política às funções do IAM do usuário usando o seguinte modelo de política: Exemplo de [lista de permissões do Data Wrangler](https://s3.us-west-2.amazonaws.com/amazon-sagemaker-data-wrangler-documentation-artifacts/DataWranglerAllowListExample.txt).
**nota**
O exemplo de política anterior só dá aos usuários acesso à aplicação Data Wrangler.
Para obter informações sobre como criar uma política, consulte [Criar políticas na guia JSON](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_create-console.html#access_policies_create-json-editor). Quando criar uma política, copie e cole a política JSON do [Exemplo de Lista de Permissões do Data Wrangler na guia](https://s3.us-west-2.amazonaws.com/amazon-sagemaker-data-wrangler-documentation-artifacts/DataWranglerAllowListExample.txt) **JSON.**
**Importante**
Exclua todas as políticas do IAM que impeçam os usuários de executar as seguintes operações:
[CreateApp](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateApp.html)
[DescribeApp](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeApp.html)
Se você não excluir as políticas, seus usuários ainda poderão ser afetados por elas.
Depois de criar a política usando o modelo, anexe-a às funções do IAM dos seus usuários. Para obter mais informações sobre anexar políticas, consulte [Adicionar permissões de identidades do IAM (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html#add-policies-console).
## Conceder permissão a um perfil do IAM para usar o Data Wrangler
Você pode conceder a um perfil do IAM permissão para usar o Data Wrangler com a política geral gerenciada do IAM, [https://console.aws.amazon.com/iam/home?#/policies/arn:aws:iam::aws:policy/AmazonSageMakerFullAccess](https://console.aws.amazon.com/iam/home?#/policies/arn:aws:iam::aws:policy/AmazonSageMakerFullAccess). Essa é uma política geral que inclui [as permissões](https://docs.aws.amazon.com/sagemaker/latest/dg/security-iam-awsmanpol-AmazonSageMakerFullAccess.html) necessárias para usar todos os serviços de SageMaker IA. Essa política concede a um perfil do IAM acesso total ao Data Wrangler. Você deve estar ciente do seguinte ao usar `AmazonSageMakerFullAccess` para conceder acesso ao Data Wrangler:
+ Se você importar dados do Amazon Redshift, o nome de **usuário do banco de dados** deverá ter o prefixo. `sagemaker_access`
+ Essa política gerenciada só concede permissão para acessar buckets com um dos seguintes no nome:`SageMaker AI`, `SageMaker AI`, `sagemaker` ou`aws-glue`. Se quiser usar o Data Wrangler para importar de um bucket do S3 sem essas frases no nome, consulte a última seção desta página para saber como conceder permissão a uma entidade do IAM para acessar seus buckets do S3.
Se você tiver necessidades de alta segurança, poderá anexar as políticas desta seção a uma entidade do IAM para conceder as permissões necessárias para usar o Data Wrangler.
Se você tiver conjuntos de dados no Amazon Redshift ou no Athena que um perfil do IAM precisa importar do Data Wrangler, você deve adicionar uma política a essa entidade para acessar esses recursos. As políticas a seguir são as políticas mais restritivas que você pode usar para dar permissão a um perfil do IAM para importar dados do Amazon Redshift e do Athena.
Para saber como anexar uma política personalizada a uma perfil do IAM, consulte [Gerenciar políticas do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage.html#create-managed-policy-console) no Guia do usuário do IAM.
**Exemplo de política para conceder acesso a uma importação de conjunto de dados do Athena**
A política a seguir pressupõe que o perfil do IAM tenha permissão para acessar o bucket S3 subjacente, onde os dados são armazenados por meio de uma política do IAM separada.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"athena:ListDataCatalogs",
"athena:ListDatabases",
"athena:ListTableMetadata",
"athena:GetQueryExecution",
"athena:GetQueryResults",
"athena:StartQueryExecution",
"athena:StopQueryExecution"
],
"Resource": [
"*"
]
},
{
"Effect": "Allow",
"Action": [
"glue:CreateTable"
],
"Resource": [
"arn:aws:glue:*:*:table/*/sagemaker_tmp_*",
"arn:aws:glue:*:*:table/sagemaker_featurestore/*",
"arn:aws:glue:*:*:catalog",
"arn:aws:glue:*:*:database/*"
]
},
{
"Effect": "Allow",
"Action": [
"glue:DeleteTable"
],
"Resource": [
"arn:aws:glue:*:*:table/*/sagemaker_tmp_*",
"arn:aws:glue:*:*:catalog",
"arn:aws:glue:*:*:database/*"
]
},
{
"Effect": "Allow",
"Action": [
"glue:GetDatabases",
"glue:GetTable",
"glue:GetTables"
],
"Resource": [
"arn:aws:glue:*:*:table/*",
"arn:aws:glue:*:*:catalog",
"arn:aws:glue:*:*:database/*"
]
},
{
"Effect": "Allow",
"Action": [
"glue:CreateDatabase",
"glue:GetDatabase"
],
"Resource": [
"arn:aws:glue:*:*:catalog",
"arn:aws:glue:*:*:database/sagemaker_featurestore",
"arn:aws:glue:*:*:database/sagemaker_processing",
"arn:aws:glue:*:*:database/default",
"arn:aws:glue:*:*:database/sagemaker_data_wrangler"
]
}
]
}
```
------
****Exemplo de política para conceder acesso a uma importação de conjunto de dados do Amazon Redshift****
A política a seguir concede permissão para configurar uma conexão do Amazon Redshift com o Data Wrangler usando usuários do banco de dados que tenham o prefixo `sagemaker_access` no nome. Para conceder permissão para se conectar usando usuários adicionais do banco de dados, adicione mais entradas sob `"Resources"` na política a seguir. A política a seguir pressupõe que o perfil do IAM tenha permissão para acessar o bucket S3 subjacente, onde os dados são armazenados por meio de uma política do IAM, se aplicável.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"redshift-data:ExecuteStatement",
"redshift-data:DescribeStatement",
"redshift-data:CancelStatement",
"redshift-data:GetStatementResult",
"redshift-data:ListSchemas",
"redshift-data:ListTables"
],
"Resource": [
"*"
]
},
{
"Effect": "Allow",
"Action": [
"redshift:GetClusterCredentials"
],
"Resource": [
"arn:aws:redshift:*:*:dbuser:*/sagemaker_access*",
"arn:aws:redshift:*:*:dbname:*"
]
}
]
}
```
------
**Política para conceder acesso para um bucket do S3**
Se seu conjunto de dados estiver armazenado no Amazon S3, você poderá conceder a um perfil do IAM permissão para acessar esse bucket com uma política semelhante à seguinte: Este exemplo concede acesso programático de leitura e gravação ao bucket chamado. *test*
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["s3:ListBucket"],
"Resource": ["arn:aws:s3:::test"]
},
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject",
"s3:DeleteObject"
],
"Resource": ["arn:aws:s3:::test/*"]
}
]
}
```
------
Para importar dados do Athena e do Amazon Redshift, você deve conceder a uma função do IAM permissão para acessar os seguintes prefixos no bucket padrão do Amazon S3 na região Data Wrangler em AWS que está sendo usado:,. `athena/` `redshift/` Se um bucket padrão do Amazon S3 ainda não existir na AWS região, você também deverá dar permissão à função do IAM para criar um bucket nessa região.
Além disso, se você quiser que a função do IAM possa usar as opções de exportação de trabalhos do Amazon SageMaker Feature Store, Pipelines e Data Wrangler, você deve conceder acesso ao prefixo `data_wrangler_flows/` nesse bucket.
O Data Wrangler usa os prefixos `athena/` e `redshift/` para armazenar arquivos de visualização e conjuntos de dados importados. Para saber mais, consulte [Armazenamento de dados importados](data-wrangler-import.md#data-wrangler-import-storage).
O Data Wrangler usa o prefixo `data_wrangler_flows/` para armazenar arquivos.flow quando você executa um caderno Jupyter exportado do Data Wrangler. Para saber mais, consulte [Exportar](data-wrangler-data-export.md).
Use uma política semelhante à seguinte para conceder as permissões descritas nos parágrafos anteriores:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:PutObject"
],
"Resource": [
"arn:aws:s3:::sagemaker-us-east-1-111122223333/data_wrangler_flows/",
"arn:aws:s3:::sagemaker-us-east-1-111122223333/data_wrangler_flows/*",
"arn:aws:s3:::sagemaker-us-east-1-111122223333/athena",
"arn:aws:s3:::sagemaker-us-east-1-111122223333/athena/*",
"arn:aws:s3:::sagemaker-us-east-1-111122223333/redshift",
"arn:aws:s3:::sagemaker-us-east-1-111122223333/redshift/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:CreateBucket",
"s3:ListBucket"
],
"Resource": "arn:aws:s3:::sagemaker-us-east-1-111122223333"
},
{
"Effect": "Allow",
"Action": [
"s3:ListAllMyBuckets",
"s3:GetBucketLocation"
],
"Resource": "*"
}
]
}
```
------
Você também pode acessar dados em seu bucket do Amazon S3 a partir de outra AWS conta especificando o URI do bucket do Amazon S3. Para fazer isso, a política do IAM que concede acesso ao bucket do Amazon S3 na outra conta deve usar uma política semelhante ao exemplo a seguir, onde `BucketFolder` está o diretório específico no bucket do usuário `UserBucket`. Essa política deve ser adicionada ao usuário que concede acesso ao bucket para outro usuário.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:PutObjectAcl"
],
"Resource": "arn:aws:s3:::UserBucket/BucketFolder/*"
},
{
"Effect": "Allow",
"Action": [
"s3:ListBucket"
],
"Resource": "arn:aws:s3:::UserBucket",
"Condition": {
"StringLike": {
"s3:prefix": [
"BucketFolder/*"
]
}
}
}
]
}
```
------
O usuário que está acessando o bucket (não o proprietário do bucket) deve adicionar uma política semelhante ao exemplo a seguir para seu usuário. Observe que `AccountX` e `TestUser` abaixo se refere ao proprietário do bucket e seu usuário, respectivamente.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:user/TestUser"
},
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:PutObjectAcl"
],
"Resource": [
"arn:aws:s3:::UserBucket/BucketFolder/*"
]
},
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::111122223333:user/TestUser"
},
"Action": [
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::UserBucket"
]
}
]
}
```
------
**Exemplo de política para conceder acesso para usar o SageMaker AI Studio**
Use uma política como a seguinte para criar um perfil de execução do IAM que possa ser usado para configurar uma instância do Studio Classic:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"sagemaker:CreatePresignedDomainUrl",
"sagemaker:DescribeDomain",
"sagemaker:ListDomains",
"sagemaker:DescribeUserProfile",
"sagemaker:ListUserProfiles",
"sagemaker:*App",
"sagemaker:ListApps"
],
"Resource": "*"
}
]
}
```
------
## Snowflake e Data Wrangler
Todas as permissões para AWS recursos são gerenciadas por meio de sua função do IAM anexada à sua instância do Studio Classic. O administrador do Snowflake gerencia as permissões específicas do Snowflake, pois pode conceder permissões e privilégios granulares a cada usuário do Snowflake. Isso inclui bancos de dados, esquemas, tabelas, armazéns e objetos de integração de armazenamento. Você deve garantir que as permissões corretas sejam configuradas fora do Data Wrangler.
Observe que o `COPY INTO Amazon S3` comando Snowflake move dados do Snowflake para o Amazon S3 pela Internet pública por padrão, mas os dados em trânsito são protegidos usando SSL. Os dados em repouso no Amazon S3 são criptografados com SSE-KMS usando o padrão. AWS KMS key
Com relação ao armazenamento de credenciais do Snowflake, o Data Wrangler não armazena as credenciais do cliente. O Data Wrangler usa o Secrets Manager para armazenar as credenciais em um segredo e alterna os segredos como parte de um plano de segurança de melhores práticas. O administrador do Snowflake ou do Studio Classic precisa garantir que o perfil de execução do Studio Classic do cientista de dados tenha permissão para realizar `GetSecretValue` no segredo que armazena as credenciais. Se já estiver vinculada ao perfil de execução do Studio Classic, a política `AmazonSageMakerFullAccess` tem as permissões necessárias para ler segredos criados pelo Data Wrangler e segredos criados seguindo a convenção de nomenclatura e marcação nas instruções acima. Segredos que não seguem as convenções devem ter acesso concedido separadamente. Recomendamos usar o Secrets Manager para evitar o compartilhamento de credenciais em canais não seguros; no entanto, observe que um usuário conectado pode recuperar a senha em texto simples iniciando um terminal ou caderno Python no Studio Classic e, em seguida, invocando chamadas de API do Secrets Manager.
## Criptografia de dados com AWS KMS
No Data Wrangler, você pode descriptografar arquivos criptografados e adicioná-los ao seu fluxo do Data Wrangler. Você também pode criptografar a saída das transformações usando uma AWS KMS chave padrão ou fornecida por você.
Você pode importar arquivos se eles tiverem o seguinte:
+ Criptografia do lado do servidor
+ SSE-KMS como o tipo de criptografia
Para descriptografar o arquivo e importá-lo para um fluxo do Data Wrangler, você deve adicionar o usuário do SageMaker Studio Classic que você está usando como usuário chave.
A captura de tela a seguir mostra uma função de usuário do Studio adicionada como usuário de chave. Consulte [Perfis do IAM](https://console.aws.amazon.com/iam/home#/roles) para acessar usuários no painel esquerdo para fazer essa alteração.
![\[A seção Usuários de chaves no console.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/data-wrangler-kms.png)
### Configuração de chave gerenciada pelo cliente do Amazon S3 para armazenamento de dados importados do Data Wrangler
Por padrão, o Data Wrangler usa buckets Amazon S3 que têm a seguinte convenção de nomenclatura: `sagemaker-region-account number`. Por exemplo, se o número da sua conta for `111122223333` e você estiver usando o Studio Classic em us-east-1, seus conjuntos de dados importados serão armazenados com a seguinte convenção de nomenclatura: `sagemaker-us-east-1-111122223333`.
As instruções a seguir explicam como configurar uma chave gerenciada pelo cliente para seu bucket padrão do Amazon S3.
1. [Para habilitar a criptografia do lado do servidor e configurar uma chave gerenciada pelo cliente para seu bucket S3 padrão, consulte Usando a criptografia KMS.](https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html)
1. Depois de seguir a etapa 1, navegue até AWS KMS em seu Console de gerenciamento da AWS. Encontre a chave gerenciada pelo cliente que você selecionou na etapa 1 da etapa anterior e adicione a função do Studio Classic como usuário de chave. Para fazer isso, siga as instruções em [Permite que os principais usuários usem uma chave gerenciada pelo cliente](https://docs.aws.amazon.com/kms/latest/developerguide/key-policies.html#key-policy-default-allow-users).
### Criptografando os dados que você exporta
É possível criptografar os dados que você exporta usando um dos seguintes métodos:
+ Para especificar que seu bucket do Amazon S3 tem objeto use a criptografia SSE-KMS.
+ Especificar uma AWS KMS chave para criptografar os dados que você exporta do Data Wrangler.
Na página **Exportar dados**, especifique um valor para o **ID da chave do AWS KMS ou ARN**.
Para obter mais informações sobre o uso de AWS KMS chaves, consulte [Proteção de dados usando criptografia do lado do servidor com AWS KMS chaves armazenadas em AWSAWS Key Management Service (SSE-KMS](https://docs.aws.amazon.com//AmazonS3/latest/userguide/UsingKMSEncryption.html)).
## AppFlow Permissões da Amazon
Ao realizar uma transferência, você deve especificar um perfil do IAM que tenha permissões para realizar a transferência. Você pode usar a mesmo perfil do IAM que tem permissões para usar o Data Wrangler. Por padrão, o perfil do IAM que você usa para acessar o Data Wrangler é o `SageMakerExecutionRole`.
O perfil do IAM também deve ter as permissões a seguir:
+ Permissões para a Amazon AppFlow
+ Permissões para o catálogo AWS Glue de dados
+ Permissões AWS Glue para descobrir as fontes de dados que estão disponíveis
Quando você executa uma transferência, a Amazon AppFlow armazena os metadados da transferência no Catálogo de AWS Glue Dados. O Data Wrangler usa os metadados do catálogo para determinar se eles estão disponíveis para consulta e importação.
Para adicionar permissões à Amazon AppFlow, adicione a política `AmazonAppFlowFullAccess` AWS gerenciada à função do IAM. Para obter mais informações sobre a adição de políticas, consulte [Adicionar ou remover permissões de identidades do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html).
Se você estiver transferindo dados para o Amazon S3, você também deve anexar a seguinte política:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"s3:GetBucketTagging",
"s3:ListBucketVersions",
"s3:CreateBucket",
"s3:ListBucket",
"s3:GetBucketPolicy",
"s3:PutEncryptionConfiguration",
"s3:GetEncryptionConfiguration",
"s3:PutBucketTagging",
"s3:GetObjectTagging",
"s3:GetBucketOwnershipControls",
"s3:PutObjectTagging",
"s3:DeleteObject",
"s3:DeleteBucket",
"s3:DeleteObjectTagging",
"s3:GetBucketPublicAccessBlock",
"s3:GetBucketPolicyStatus",
"s3:PutBucketPublicAccessBlock",
"s3:PutAccountPublicAccessBlock",
"s3:ListAccessPoints",
"s3:PutBucketOwnershipControls",
"s3:PutObjectVersionTagging",
"s3:DeleteObjectVersionTagging",
"s3:GetBucketVersioning",
"s3:GetBucketAcl",
"s3:PutObject",
"s3:GetObject",
"s3:GetAccountPublicAccessBlock",
"s3:ListAllMyBuckets",
"s3:GetAnalyticsConfiguration",
"s3:GetBucketLocation"
],
"Resource": "*"
}
]
}
```
------
Para adicionar AWS Glue permissões, adicione a política `AWSGlueConsoleFullAccess` gerenciada à função do IAM. Para obter mais informações sobre AWS Glue permissões com a Amazon AppFlow, consulte [link-to-appflow-page].
A Amazon AppFlow precisa acessar AWS Glue um Data Wrangler para que você importe os dados que você transferiu. Para conceder AppFlow acesso à Amazon, adicione a seguinte política de confiança à função do IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam::123456789012:root",
"Service": [
"appflow.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Para exibir os AppFlow dados da Amazon no Data Wrangler, adicione a seguinte política à função do IAM:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "glue:SearchTables",
"Resource": [
"arn:aws:glue:*:*:table/*/*",
"arn:aws:glue:*:*:database/*",
"arn:aws:glue:*:*:catalog"
]
}
]
}
```
------
## Usando configurações de ciclo de vida no Data Wrangler
Você pode ter uma instância do Amazon EC2 configurada para executar aplicações Kernel Gateway, mas não a aplicação Data Wrangler. As aplicações Kernel Gateway fornecem acesso ao ambiente e aos kernels que você usa para executar cadernos do Studio Classic e terminais. A aplicação Data Wrangler é a aplicação de interface do usuário que executa o Data Wrangler. As instâncias do Amazon EC2 que não são instâncias do Data Wrangler exigem uma modificação em suas configurações de ciclo de vida para executar o Data Wrangler. As configurações de ciclo de vida são scripts de shell que automatizam a personalização do seu ambiente Amazon SageMaker Studio Classic.
Para obter mais informações sobre a configuração de ciclo de vida, consulte [Use configurações de ciclo de vida para personalizar o Amazon Studio Classic SageMaker](studio-lcc.md).
A configuração padrão do ciclo de vida da sua instância não é compatível com o uso do Data Wrangler. Você pode fazer as seguintes modificações na configuração padrão para usar o Data Wrangler com sua instância:
```
#!/bin/bash
set -eux
STATUS=$(
python3 -c "import sagemaker_dataprep"
echo $?
)
if [ "$STATUS" -eq 0 ]; then
echo 'Instance is of Type Data Wrangler'
else
echo 'Instance is not of Type Data Wrangler'
# Replace this with the URL of your git repository
export REPOSITORY_URL="https://github.com/aws-samples/sagemaker-studio-lifecycle-config-examples.git"
git -C /root clone $REPOSTIORY_URL
fi
```
Você pode salvar o script como `lifecycle_configuration.sh`.
Você anexa a configuração do ciclo de vida a um domínio do Studio Classic ou a um perfil de usuário. Para obter mais informações sobre criar e gerenciar uma configuração de ciclo de vida, consulte [Crie e associe uma configuração de ciclo de vida ao Amazon Studio Classic SageMaker](studio-lcc-create.md).
As instruções a seguir mostram como anexar a configuração do ciclo de vida a um domínio do Studio Classic ou a um perfil de usuário.
Você pode encontrar erros ao criar ou anexar uma configuração de ciclo de vida. Para obter informações sobre depuração da configuração do ciclo de vida, consulte [KernelGateway falha no aplicativo](studio-lcc-debug.md#studio-lcc-debug-kernel).
# Notas da versão
O Data Wrangler é atualizado regularmente com novos atributos e correções de bugs. Para atualizar a versão do Data Wrangler que você está usando no Studio Classic, siga as instruções em [Encerre e atualize os aplicativos do Amazon SageMaker Studio Classic](studio-tasks-update-apps.md).
****
| Notas da versão |
| --- |
| **31/08/2023** Nova função: Agora você pode criar um relatório de qualidade dos dados e insights em todo o seu conjunto de dados. Para obter mais informações, consulte [Obtenha insights sobre dados e qualidade dos dados](data-wrangler-data-insights.md). **20/05/2023** Nova função: Agora você pode importar seus dados do Salesforce Data Cloud. Para obter mais informações, consulte [Importar dados do Salesforce Data Cloud](data-wrangler-import.md#data-wrangler-import-salesforce-data-cloud). **18/04/2023** Nova função: Agora você pode obter seus dados em um formato que o Amazon Personalize possa interpretar. Para obter mais informações, consulte [Colunas de mapas do Amazon Personalize](data-wrangler-transform.md#data-wrangler-transform-personalize). **01/03/2023** Nova função: Agora você pode usar o Hive para importar seus dados do Amazon EMR. Para obter mais informações, consulte [Importar dados do Amazon EMR](data-wrangler-import.md#data-wrangler-emr). **10/12/2022** Nova função: Agora você pode exportar seu fluxo do Data Wrangler para um endpoint de inferência. Para obter mais informações, consulte [Exportar para um endpoint de inferência](data-wrangler-data-export.md#data-wrangler-data-export-inference). Nova função: Agora você pode usar um widget de caderno interativo para a preparação de dados. Para obter mais informações, consulte [Use um widget interativo de preparação de dados em um notebook Amazon SageMaker Studio Classic para obter insights de dados](data-wrangler-interactively-prepare-data-notebook.md). Nova função: Agora você pode importar dados de plataformas SaaS. Para obter mais informações, consulte [Importar dados de plataformas de software como serviço (SaaS)](data-wrangler-import.md#data-wrangler-import-saas). **12/10/2022** Nova função: Agora você pode reutilizar fluxos de dados para conjuntos de dados diferentes. Para obter mais informações, consulte [Reutilização de fluxos de dados para diferentes conjuntos de dados](data-wrangler-parameterize.md). **10/05/2022** Nova função: Agora você pode usar a Análise de Componentes Principais (PCA) como uma transformação. Para obter mais informações, consulte [Reduza a dimensionalidade em um conjunto de dados](data-wrangler-transform.md#data-wrangler-transform-dimensionality-reduction). **10/05/2022** Nova função: Agora você pode reajustar os parâmetros em seu fluxo do Data Wrangler. Para obter mais informações, consulte [Exportar](data-wrangler-data-export.md). **10/03/2022** Nova função: Agora você pode implantar modelos a partir do seu fluxo do Data Wrangler. Para obter mais informações, consulte [Treine modelos automaticamente em seu fluxo de dados](data-wrangler-autopilot.md). **20/09/2022** Nova função: Agora você pode configurar períodos de retenção de dados no Athena. Para obter mais informações, consulte [Importar dados do Athena](data-wrangler-import.md#data-wrangler-import-athena). **09/06/2022** Nova função: Agora você pode usar o Amazon SageMaker Autopilot para treinar um modelo diretamente do seu fluxo do Data Wrangler. Para obter mais informações, consulte [Treine modelos automaticamente em seu fluxo de dados](data-wrangler-autopilot.md). **6/5/2022** Nova função: Agora você pode usar instâncias m5 e r5 adicionais. Para obter mais informações, consulte [Instâncias](data-wrangler-data-flow.md#data-wrangler-data-flow-instances). **27/04/2022** Novas funcionalidades: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/data-wrangler-release-notes.html) **01/04/2022** Nova função: Agora você pode usar o Databricks como fonte de dados. Para obter mais informações, consulte [Importar dados do Databricks (JDBC)](data-wrangler-import.md#data-wrangler-databricks). **2/2/2022** Novas funcionalidades: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/data-wrangler-release-notes.html) **16/10/2021** Nova função: O Data Wrangler agora oferece apoio aos grupos de trabalho do Athena. Para obter mais informações, consulte [Importar dados do Athena](data-wrangler-import.md#data-wrangler-import-athena). **6/10/2021** Nova função: O Data Wrangler agora oferece apoio à transformação de dados de séries temporais. Para obter mais informações, consulte [Séries temporais de transformações](data-wrangler-transform.md#data-wrangler-transform-time-series). **15/07/2021** Novas funcionalidades: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/data-wrangler-release-notes.html) Aprimoramentos: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/data-wrangler-release-notes.html) Correções de bugs: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/data-wrangler-release-notes.html) **26/04/2021** Aprimoramentos: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/data-wrangler-release-notes.html) Correções de bugs: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/data-wrangler-release-notes.html) **08/02/2021** Novas funcionalidades: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/data-wrangler-release-notes.html) Aprimoramentos: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/data-wrangler-release-notes.html) Correções de bugs: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/data-wrangler-release-notes.html) |
# Solução de problemas
Se surgir um problema ao usar o Amazon SageMaker Data Wrangler, recomendamos que você faça o seguinte:
+ Se uma mensagem de erro for fornecida, leia a mensagem e resolva o problema que ela relata, se possível.
+ Certifique-se de que o perfil do IAM do seu usuário do Studio Classic tenha as permissões necessárias para realizar a ação. Para obter mais informações, consulte [Segurança e permissões](data-wrangler-security.md).
+ Se o problema ocorrer ao tentar importar de outro AWS serviço, como Amazon Redshift ou Athena, verifique se você configurou as permissões e os recursos necessários para realizar a importação de dados. Para obter mais informações, consulte [Importar](data-wrangler-import.md).
+ Se você ainda estiver tendo problemas, escolha **Obter ajuda** no canto superior direito da tela para entrar em contato com a equipe do Data Wrangler. Para obter mais informações, consulte as seguintes imagens:
![\[A localização do formulário de ajuda do Data Wrangler no console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/get-help/get-help.png)
![\[O formulário de ajuda do Data Wrangler no console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/get-help/get-help-forms.png)
Como último recurso, você pode tentar reiniciar o kernel no qual o Data Wrangler está sendo executado.
1. Salve e saia do arquivo .flow do qual você deseja reiniciar o kernel.
1. Selecione o ícone ****Terminais e kernels em execução****, conforme mostrado na imagem a seguir.
![\[A localização do ícone de Terminais e kernels em execução no console.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/stop-kernel-option.png)
1. Selecione o ícone **Parar** à direita do arquivo.flow para o qual você deseja encerrar o kernel, conforme mostrado na imagem a seguir.
![\[A localização do ícone Parar no console.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/studio/mohave/stop-kernel.png)
1. Atualize o navegador.
1. Reabra o arquivo .flow no qual você estava trabalhando.
## Solucionar problemas com o Amazon EMR
Use as informações a seguir para ajudá-lo a solucionar erros que podem surgir ao usar o Amazon EMR.
+ Falha na conexão: Se a conexão falhar com a seguinte mensagem `The IP address of the EMR cluster isn't private error message`, seu cluster do Amazon EMR pode não ter sido lançado em uma sub-rede privada: Como uma prática recomendada de segurança, o Data Wrangler só oferece apoio à conexão com clusters privados do Amazon EMR. Escolha uma sub-rede EC2 privada para iniciar um cluster EMR.
+ Conexão interrompida e tempo limite: O problema provavelmente se deve a um problema de conectividade de rede. Depois que você começa a se conectar ao cluster, a tela não é atualizada. Após cerca de 2 minutos, você poderá ver o seguinte erro `JdbcAddConnectionError: An error occurred when trying to connect to presto: xxx: Connect to xxx failed: Connection timed out (Connection timed out) will display on top of the screen.`:
Os erros podem ter duas causas principais:
+ O Amazon EMR e o Amazon SageMaker Studio Classic são diferentes. VPCs Recomendamos iniciar o Amazon EMR e o Studio Classic na mesma VPC. Você também pode usar o emparelhamento de VPC. Para obter mais informações, consulte [O que é emparelhamento de VPC?](https://docs.aws.amazon.com/vpc/latest/peering/what-is-vpc-peering.html)
+ O grupo de segurança principal do Amazon EMR não tem a regra de tráfego de entrada para o grupo de segurança do Amazon SageMaker Studio Classic na porta usada para o Presto. Para resolver o problema, permita o tráfego de entrada na porta 8889.
+ A conexão falha devido ao tipo de conexão estar configurado incorretamente: Você pode ver a seguinte mensagem de erro: ` Data Wrangler couldn't create a connection to {connection_source} successfully. Try connecting to {connection_source} again. For more information, see Troubleshoot. If you’re still experiencing issues, contact support. `
Verifique o método de autenticação. O método de autenticação que você especificou no Data Wrangler deve corresponder ao método de autenticação que você está usando no cluster.
+ Você não tem permissões do HDFS para autenticação LDAP: Use as orientações a seguir para resolver o problema [Configure as permissões do HDFS usando credenciais do Linux](https://docs.aws.amazon.com/whitepapers/latest/teaching-big-data-skills-with-amazon-emr/set-up-hdfs-permissions-using-linux-credentials.html). Você pode fazer login no cluster usando os seguintes comandos: :
```
hdfs dfs -mkdir /user/USERNAME
hdfs dfs -chown USERNAME:USERNAME /user/USERNAME
```
+ Erro de chave de conexão ausente na autenticação LDAP: Você pode ver a seguinte mensagem de erro:. `Data Wrangler couldn't connect to EMR hive successfully. JDBC connection is missing required connection key(s): PWD`
Para a autenticação LDAP, você deve especificar um nome de usuário e uma senha. A URL do JDBC armazenada no Secrets Manager é propriedade ausente `PWD`.
+ Ao solucionar problemas de configuração LDAP: Recomendamos certificar-se de que o autenticador LDAP (servidor LDAP) esteja configurado corretamente para se conectar ao cluster do Amazon EMR. Use o comando `ldapwhoami` para ajudar a resolver o problema de configuração. A seguir estão exemplos de comandos que você pode executar:
+ Para LDAPS: `ldapwhoami -x -H ldaps://ldap-server`
+ Para LDAP: `ldapwhoami -x -H ldap://ldap-server`
Qualquer um dos comandos deve retornar `Anonymous` se você tiver configurado o autenticador com sucesso.
## Solução de problemas com o Salesforce
### Erro de configuração do ciclo de vida
Quando o usuário abre o Studio pela primeira vez, ele pode receber um erro informando que há algo errado com a configuração do ciclo de vida. Use CloudWatch a Amazon para acessar os registros escritos pelo seu script de configuração do ciclo de vida. Para obter mais informações sobre depuração de configurações de ciclo de vida, consulte [Depurar configurações de ciclo de vida no Amazon Studio Classic SageMaker](studio-lcc-debug.md).
Se não conseguir depurar o erro, você poderá criar o arquivo de configuração manualmente. Você deve criar o arquivo sempre que excluir ou reiniciar o servidor Jupyter. Use o procedimento a seguir para criar o arquivo manualmente.
**Para criar um arquivo de configuração**
1. Navegue até o Studio Classic.
1. Escolha **Arquivo**, depois **Novo** e, em seguida, **Terminal**.
1. Criar `.sfgenie_identity_provider_oauth_config`.
1. Abra o arquivo em um editor de textos.
1. Adicione um objeto JSON contendo o nome de recurso da Amazon (ARN) do segredo do Secrets Manager ao arquivo. O modelo a seguir pode ser usado para criar o objeto.
```
{
"secret_arn": "example-secret-ARN"
}
```
1. Salve as alterações no arquivo .
### Não é possível acessar o Salesforce Data Cloud a partir do fluxo do Data Wrangler
Depois que seu usuário escolher o **Salesforce Data Cloud** em seu fluxo do Data Wrangler, ele poderá receber um erro indicando que os pré-requisitos para configurar a conexão não foram atendidos. Isso pode ser causado pelos seguintes erros:
+ O segredo do Salesforce no Secrets Manager não foi criado.
+ O segredo do Salesforce no Secrets Manager foi criado, mas não tem a tag Salesforce.
+ O segredo do Salesforce no Secrets Manager foi criado de forma errada. Região da AWS Por exemplo, seu usuário não poderá acessar o Salesforce Data Cloud em `ca-central-1` porque você criou o segredo em `us-east-1`. Você pode replicar o segredo para `ca-central-1` ou criar um novo segredo com as mesmas credenciais em `ca-central-1`. Para obter informações sobre como replicar segredos, consulte [Replicar um AWS Secrets Manager segredo para outra pessoa](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create-manage-multi-region-secrets.html). Regiões da AWS
+ A política que seus usuários estão usando para acessar o Amazon SageMaker Studio Classic não tem permissões para AWS Secrets Manager
+ Há um erro de digitação no ARN do Secrets Manager do objeto JSON que você especificou por meio da configuração do ciclo de vida.
+ Há um erro de digitação no segredo do Secrets Manager contendo sua configuração do Salesforce OAuth
### Exibição de página em branco `redirect_uri_mismatch`
Depois que seus usuários escolherem **Salvar e Conectar**, eles poderão ser redirecionados para uma página exibida `redirect_uri_mismatch`. O URI de retorno de chamada registrado nas configurações da aplicação Salesforce Connected está ausente ou incorreto.
Use o seguinte URL para verificar se o URL do Studio Classic está registrado corretamente nas configurações de aplicação conectado da sua organização Salesforce: `https://EXAMPLE_SALESFORCE_ORG/lightning/setup/NavigationMenus/home/`. Para obter mais informações sobre como usar as configurações da aplicação conectado, navegue até o seguinte URL: `https://EXAMPLE_SALESFORCE_ORG/lightning/setup/NavigationMenus/home/`.
**nota**
São necessários aproximadamente dez minutos para propagar o URI nos sistemas da Salesforce.
### Espaços compartilhados
Atualmente, os espaços compartilhados não funcionam com a integração do Salesforce Data Cloud. Você pode excluir os espaços compartilhados no domínio Amazon SageMaker AI que você pretende usar ou pode usar outro domínio que não tenha espaços compartilhados configurados.
### OAuth Erro de redirecionamento
Seus usuários devem poder importar seus dados do Salesforce Data Cloud depois de escolherem **Connect**. Se eles encontrarem um erro, recomendamos pedir que façam o seguinte:
+ Peça que eles sejam pacientes — Quando eles são redirecionados de volta para o Amazon SageMaker Studio Classic, pode levar até um minuto para concluir o processo de autenticação. Enquanto eles estão sendo redirecionados, recomendamos que eles evitem interagir com o navegador. Por exemplo, eles não devem fechar a guia do navegador, mudar para outra guia ou interagir com o fluxo do Data Wrangler. A interação com o navegador pode remover o código de autorização necessário para conectar-se à nuvem de dados.
+ Faça com que seus usuários se reconectem à nuvem de dados: Há problemas transitórios que podem causar falha na conexão com o Salesforce Data Cloud. Faça com que seus usuários criem um novo fluxo do Data Wrangler e tentem se conectar novamente ao Salesforce Data Cloud.
+ Certifique-se de que seus usuários fechem todas as outras guias com o Amazon SageMaker Studio Classic — Ter o Studio Classic aberto em várias guias pode causar falha na conexão com o Salesforce Data Cloud. Certifique-se de que seus usuários tenham apenas uma guia do Studio Classic aberta.
+ Vários usuários acessando o Studio Classic ao mesmo tempo — Somente um usuário deve acessar um domínio Amazon SageMaker AI por vez. Se vários usuários acessarem o mesmo domínio, a conexão que um usuário está tentando criar com o Salesforce Data Cloud pode falhar.
A atualização do Data Wrangler e do Studio Classic também pode corrigir o erro. Para obter informações sobre como atualizar o Data Wrangler, consulte [Atualizar o Data Wrangler](data-wrangler-update.md). Para obter informações sobre como atualizar o Studio Classic, consulte [Desligue e atualize o Amazon SageMaker Studio Classic](studio-tasks-update-studio.md).
Se nenhuma das etapas de solução de problemas anteriores funcionar, você poderá encontrar uma mensagem de erro do Salesforce com uma descrição correspondente incorporada no URL do Studio Classic. A seguir está um exemplo de mensagem que você pode encontrar: `error=invalid_client_id&error_description=client%20identifier%20invalid`.
Você pode observar a mensagem de erro no URL e tentar resolver os problemas que ela apresenta. Se a mensagem ou descrição do erro não estiver clara, recomendamos pesquisar na Base de conhecimento do Salesforce. Se a pesquisa na base de conhecimento não funcionar, você pode entrar em contato com o Help Desk do Salesforce para obter mais assistência.
### O Data Wrangler leva muito tempo para carregar
Quando seus usuários são redirecionados de volta para o Data Wrangler a partir do Salesforce Data Cloud, eles podem enfrentar longos tempos de carregamento.
Se for a primeira vez que o usuário usa o Data Wrangler ou se ele tiver excluído o kernel, pode levar cerca de 5 minutos para provisionar a nova instância do Amazon EC2 para usar o Data Wrangler.
Se esta não for a primeira vez que o usuário usa o Data Wrangler e ele não tiver excluído o kernel, você pode solicitar que ele atualize a página ou feche tantas guias do navegador quanto possível.
Se nenhuma das intervenções anteriores funcionar, peça-lhes que configurem uma nova conexão com o Salesforce Data Cloud.
### O usuário falha ao exportar seus dados com um erro `Invalid batch Id`
Quando seu usuário exporta as transformações que ele fez em seus dados do Salesforce, a tarefa de SageMaker processamento que o Data Wrangler usa no back-end pode falhar. O Salesforce Data Cloud pode estar temporariamente indisponível ou pode haver um problema de armazenamento em cache.
Para resolver o problema, recomendamos que os usuários voltem à etapa em que estão importando os dados e alterando a ordem das colunas que estão consultando . Por exemplo, eles podem alterar a seguinte consulta:
```
SELECT col_A, col_B FROM table
```
Para a seguinte consulta:
```
SELECT col_B, col_A FROM table
```
Depois de alterar a ordem das colunas e certificar-se de que as transformações subsequentes feitas ainda são válidas, eles poderão começar a exportar seus dados novamente.
### Os usuários não podem exportar um conjunto de dados muito grande
Se seus usuários importaram um conjunto de dados muito grande do Salesforce Data Cloud, talvez não consigam exportar as transformações que fizeram. Um conjunto de dados grande pode ter muitas linhas ou pode resultar de uma consulta complexa.
Recomendamos que seus usuários realizem as seguintes ações:
+ Simplificar sua consulta SQL
+ Amostragem de seus dados
A seguir estão algumas estratégias que eles podem usar para simplificar suas consultas:
+ Especifique os nomes das colunas em vez de usar o operador `*`
+ Encontrar um subconjunto de dados que eles gostariam de importar em vez de usar um subconjunto maior
+ Minimizando as junções entre conjuntos de dados muito grandes
Eles podem usar amostragem para reduzir o número de linhas em seu conjunto de dados. Para obter informações sobre métodos de amostragem, seus usuários podem consultar [Amostragem](data-wrangler-transform.md#data-wrangler-transform-sampling).
### Os usuários não podem exportar dados devido ao token de atualização inválido
O Data Wrangler usa um driver JDBC para se integrar ao Salesforce Data Cloud. O método de autenticação é OAuth. Pois OAuth, o token de atualização e o token de acesso são dois dados diferentes que são usados para autorizar o acesso aos recursos em sua Salesforce Data Cloud.
O token de acesso, ou token principal, é o que permite acessar seus dados do Salesforce e executar consultas diretamente por meio do Data Wrangler. É de curta duração e foi desenvolvido para expirar rapidamente. Para manter o acesso aos seus dados do Salesforce, o Data Wrangler usa o token de atualização para obter um novo token de acesso do Salesforce.
Talvez você tenha configurado a atualização para expirar muito rapidamente para obter um novo token de acesso para seus usuários. Talvez seja necessário revisitar sua política de token de atualização para garantir que ela possa acomodar consultas que demoram muito para serem executadas para seus usuários. Para obter informações sobre como configurar a política de token de atualização, consulte `https://EXAMPLE_SALESFORCE_ORG_URL/lightning/setup/ConnectedApplication/home/`.
### As consultas falham ou as tabelas não são carregadas
A Salesforce enfrenta interrupções no serviço. Mesmo que você tenha configurado tudo corretamente, seus usuários talvez não consigam importar seus dados por períodos de tempo.
Paralisações no serviço podem ocorrer por motivos de manutenção. Recomendamos verificar no dia seguinte para ver se o problema foi resolvido:
Se você estiver enfrentando problemas há mais de um dia, recomendamos entrar em contato com a Help Desk do Salesforce para obter mais assistência. Para obter informações sobre como entrar em contato com a Salesforce, consulte [Como você gostaria de entrar em contato com a Salesforce?](https://www.salesforce.com/company/contact-us/)
### `OAUTH_APP_BLOCKED` durante o redirecionamento do Studio Classic
Quando seu usuário é redirecionado de volta para o Amazon SageMaker Studio Classic, ele pode observar o parâmetro de consulta `error=OAUTH_APP_BLOCKED` dentro da URL. Eles podem estar enfrentando um problema transitório que deve se resolver dentro de um dia.
É possível que você também tenha bloqueado o acesso deles ao Connected App. Para obter informações sobre como resolver o problema, consulte `https://EXAMPLE_SALESFORCE_ORG_URL/lightning/setup/ConnectedApplication/home/`.
### `OAUTH_APP_DENIED` durante o redirecionamento do Studio Classic
Quando seu usuário é redirecionado de volta para o Amazon SageMaker Studio Classic, ele pode observar o parâmetro de consulta `error=OAUTH_APP_ACCESS_DENIED` dentro da URL. Você não concedeu às pessoas permissões de tipo de perfil para acessar o `Connected App` associado ao Data Wrangler.
Para resolver o problema de acesso, navegue até o perfil correto `https://EXAMPLE_SALESFORCE_ORG_URL/lightning/setup/ManageUsers/home/` e verifique se o usuário está atribuído ao perfil correto.
# Aumente o limite de instâncias do Amazon EC2
Você poderá ver a mensagem de erro a seguir ao usar o Data Wrangler: `The following instance type is not available: ml.m5.4xlarge. Try selecting a different instance below.`
A mensagem pode indicar que você precisa selecionar um tipo de instância diferente, mas também pode indicar que você não tem instâncias suficientes do Amazon EC2 para executar com sucesso o Data Wrangler em seu fluxo de trabalho. Você pode aumentar o número de instâncias usando o procedimento a seguir.
Para aumentar o número de instâncias, faça o seguinte:
1. Abra Console de gerenciamento da AWS o.
1. Na barra de pesquisa, especifique **Services Quotas**.
1. Escolha **Service Quotas**.
1. Selecione **Serviço da AWS **.
1. Na barra de pesquisa, especifique **Amazon SageMaker AI**.
1. Escolha **Amazon SageMaker AI**.
1. Em **Cotas de serviço**, especifique **Studio KernelGateway Apps running on *ml.m5.4xlarge* instance**.
**nota**
O tipo de instância padrão do Data Wrangler é ml.m5.4xlarge. Você pode usar outros tipos de instância e solicitar aumentos de cota para eles. Para obter mais informações, consulte [Instâncias](data-wrangler-data-flow.md#data-wrangler-data-flow-instances).
1. Selecione **Studio KernelGateway Apps em execução na *ml.m5.4xlarge* instância**.
1. Selecione **Solicitar aumento de cota**.
1. Em **Alterar valor da cota**, especifique um valor maior que o **valor da cota aplicada**.
1. Escolha **Solicitar**.
Se sua solicitação for aprovada, AWS enviará uma notificação para o endereço de e-mail associado à sua conta. Você também pode verificar o status da sua solicitação escolhendo **Histórico de solicitações de cotas** na página **Service Quotas**. As solicitações processadas têm um **status** de **Fechado**.
# Atualizar o Data Wrangler
Para atualizar o Data Wrangler para a versão mais recente, primeiro desligue o KernelGateway aplicativo correspondente no painel de controle do Amazon SageMaker Studio Classic. Depois que o KernelGateway aplicativo for encerrado, reinicie-o abrindo um fluxo de Data Wrangler novo ou existente no Studio Classic. Quando você abre um fluxo novo ou existente do Data Wrangler, o kernel que inicia contém a versão mais recente do Data Wrangler.
**Atualize a instância do Studio Classic e do Data Wrangler**
1. Navegue até seu [console de SageMaker IA](https://console.aws.amazon.com/sagemaker).
1. Escolha SageMaker AI e depois Studio Classic.
1. Escolha o seu nome de usuário.
1. Em **Aplicativos**, na linha que exibe o **nome do aplicativo**, escolha **Excluir aplicativo** para o aplicativo que começa com `sagemaker-data-wrang` e para o JupyterServer aplicativo.
1. Escolha **Sim, excluir aplicação**.
1. Digite `delete` na caixa de confirmação.
1. Escolha **Excluir**.
1. Reabra sua instância do Studio Classic. Quando você começa a criar um fluxo do Data Wrangler, sua instância agora usa a versão mais recente do Data Wrangler.
Como alternativa, se você estiver usando uma versão da aplicação Data Wrangler que não seja a versão mais recente e tiver um fluxo existente do Data Wrangler aberto, você será solicitado a atualizar a versão da aplicação Data Wrangler na interface do Studio Classic. A captura de tela a seguir mostra este prompt.
**Importante**
Isso atualiza somente a aplicação de gateway de kernel do Data Wrangler. Você ainda precisa desligar o JupyterServer aplicativo em sua conta de usuário. Para isso, siga as etapas anteriores.
![\[A seção Atualizar Data Wrangler no console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/data-wrangler-1click-restart.png)
Você também pode escolher **Lembrar-me mais tarde**; nesse caso, um botão **Atualizar** aparece no canto superior direito da tela.
![\[A localização do Atualizar no console do Data Wrangler.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/data-wrangler-1click-restart-update.png)
# Encerrando o Data Wrangler
Quando você não estiver usando o Data Wrangler, é importante encerrar a instância na qual ele é executado para evitar taxas adicionais.
Para evitar perder trabalho, salve seu fluxo de dados antes de desligar o Data Wrangler. Para salvar seu fluxo de dados no Studio Classic, escolha **Arquivo** e, em seguida, escolha **Salvar fluxo do Data Wrangler**. O Data Wrangler salvará automaticamente seu fluxo de dados a cada 60 segundos.
**Para encerrar a instância do Data Wrangler no Studio Classic**
1. No Studio Classic, selecione o ícone **Instâncias e kernels em execução** (![\[Icon of a gear or cog symbol representing settings or configuration options.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/icons/studio_classic_dw_instances.png)).
1. Em **RUNNING APPS** está o aplicativo **sagemaker-data-wrangler-1.0**. Selecione o ícone de encerramento (![\[Power button icon with a circular shape and vertical line symbol.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/icons/Shutdown_light.png)) ao lado da aplicação.
O Data Wrangler é executado em uma instância ml.m5.4xlarge. Essa instância desaparece de **INSTÂNCIAS EM EXECUÇÃO** quando você desliga a aplicação Data Wrangler.
**Importante**
Se você abrir o Data Wrangler novamente, uma instância do Amazon EC2 começará a executar a aplicação e você será cobrado pela computação. Além da computação, você também é cobrado pelo armazenamento que usa. Por exemplo, você é cobrado por todos os buckets do Amazon S3 que estiver usando com o Data Wrangler.
Se você descobrir que ainda está sendo cobrado pelo Data Wrangler depois de encerrar suas aplicações, há uma extensão do Jupyter que você pode usar para encerrar automaticamente as sessões ociosas. Para obter informações sobre a extensão, consulte [SageMaker-Studio-Autoshutdown-Extension](https://github.com/aws-samples/sagemaker-studio-auto-shutdown-extension).
Depois de encerrar a aplicação Data Wrangler, ela deverá ser reiniciada na próxima vez que você abrir um arquivo de fluxo do Data Wrangler. Isso pode levar alguns minutos.