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á. # Execução de workloads interativas no Amazon EMR no EKS Um *endpoint interativo* corresponde a um gateway que conecta o Amazon EMR Studio ao Amazon EMR no EKS para que você possa executar workloads interativas. É possível usar endpoints interativos com o EMR Studio para executar analytics interativos com conjuntos de dados em armazenamentos de dados como o [Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/) e o [Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/gettingstartedguide/). **Casos de uso** + Criação de um script de ETL com a experiência do IDE do EMR Studio. O IDE ingere dados on-premises e os armazena no Amazon S3 após as transformações para análises posteriores. + Uso de cadernos para explorar conjuntos de dados e treinar um modelo de machine learning para detectar anomalias nos conjuntos de dados. + Criação de scripts que geram relatórios diários para aplicações de análise, como painéis de negócios. **Topics** + [Visão geral dos endpoints interativos](how-it-works.md) + [Pré-requisitos para a criação de um endpoint interativo no Amazon EMR no EKS](prereqs-for-studio.md) + [Criação de um endpoint interativo para o cluster virtual](create-managed-endpoint.md) + [Definição de configurações para endpoints interativos](managed-endpoint-parameters.md) + [Monitoramento de endpoints interativos](managed-endpoints-customer-metrics.md) + [Uso de cadernos Jupyter de hospedagem própria](managed-endpoints-self-hosted.md) + [Como obter informações sobre endpoints interativos com comandos da CLI](other-operations.md) # Visão geral dos endpoints interativos Um *endpoint interativo* fornece a funcionalidade para os clientes interativos, como os que usam o Amazon EMR Studio, de se conectarem ao Amazon EMR em clusters do EKS para executar workloads interativas. O endpoint interativo está respaldado pelo Jupyter Enterprise Gateway que fornece a funcionalidade de gerenciamento remoto do ciclo de vida do kernel de que os clientes interativos precisam. Os *kernels* são processos específicos de linguagem que interagem com o cliente do Amazon EMR Studio baseado em Jupyter para executar workloads interativas. Os endpoints interativos oferecem suporte aos seguintes kernels: + Python 3 + PySpark no Kubernetes + Apache Spark com o Scala **nota** Os preços do Amazon EMR no EKS se aplicam aos endpoints e aos kernels interativos. Para obter mais informações, consulte a página [Preços do Amazon EMR no EKS](https://aws.amazon.com/emr/pricing/#Amazon_EMR_on_Amazon_EKS). As entidades apresentadas a seguir são necessárias para que o EMR Studio se conecte ao Amazon EMR no EKS. + **Cluster virtual do Amazon EMR no EKS**: um *cluster virtual* corresponde a um namespace do Kubernetes no qual você registra o Amazon EMR. O Amazon EMR usa clusters virtuais para executar trabalhos e hospedar endpoints. É possível fazer backup de vários clusters virtuais usando o mesmo cluster físico. No entanto, cada cluster virtual é mapeado para um namespace em um cluster do Amazon EKS. Os clusters virtuais não criam quaisquer recursos ativos que contribuam para o seu faturamento ou que requeiram gerenciamento do ciclo de vida de forma externa ao serviço. + **Endpoint interativo do Amazon EMR no EKS**: um *endpoint interativo* corresponde a um endpoint HTTPS ao qual os usuários do EMR Studio podem conectar um Workspace. É possível acessar os endpoints HTTPS somente ao usar o EMR Studio e criá-los em uma sub-rede privada da Amazon Virtual Private Cloud (Amazon VPC) para o cluster do Amazon EKS. Os kernels Python, PySpark, e Spark Scala usam as permissões definidas na função de execução de tarefas do Amazon EMR no EKS para invocar outras. Serviços da AWS Todos os kernels e os usuários que se conectam ao endpoint interativo utilizam o perfil que você especificou ao criar o endpoint. Recomendamos que você crie endpoints separados para usuários diferentes e que os usuários tenham funções diferentes AWS Identity and Access Management (IAM). + AWS Controlador do **Application Load Balancer — O controlador** do *AWS Application Load Balancer* gerencia o Elastic Load Balancing para um cluster Amazon EKS Kubernetes. O controlador provisiona um Application Load Balancer (ALB) quando você cria um recurso Ingress do Kubernetes. Um ALB revela um serviço do Kubernetes, como um endpoint interativo, de forma externa ao cluster do Amazon EKS, mas dentro da mesma Amazon VPC. Ao criar um endpoint interativo, também ocorre a implementação de um recurso Ingress que revela o endpoint interativo por meio do ALB para os clientes interativos se conectarem. Você só precisa instalar um controlador do AWS Application Load Balancer para cada cluster do Amazon EKS. O diagrama a seguir descreve a arquitetura dos endpoints interativos no Amazon EMR no EKS. Um cluster do Amazon EKS compreende a *computação* para executar as workloads de análise e o *endpoint interativo*. O controlador do Application Load Balancer é executado no namespace `kube-system`, enquanto as workloads e os endpoints interativos são executados no namespace especificado ao criar o cluster virtual. Quando você cria um endpoint interativo, o ambiente de gerenciamento do Amazon EMR no EKS cria a implantação do endpoint interativo no cluster do Amazon EKS. Além disso, uma instância da entrada do balanceador de carga do aplicativo é criada pelo controlador do balanceador de AWS carga. O Application Load Balancer fornece a interface externa para que os clientes, como o EMR Studio, se conectem ao cluster do Amazon EMR e executem workloads interativas. ![\[Diagrama da arquitetura dos endpoints interativos.\]](http://docs.aws.amazon.com/pt_br/emr/latest/EMR-on-EKS-DevelopmentGuide/images/emr-on-eks-managed-endpoints-architecture.png) # Pré-requisitos para a criação de um endpoint interativo no Amazon EMR no EKS Esta seção descreve os pré-requisitos para configurar um endpoint interativo que o EMR Studio poderá usar para se conectar a um cluster do Amazon EMR no EKS e executar workloads interativas. ## AWS CLI Siga as etapas em [Instalar ou atualizar para a versão mais recente do AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) para instalar a versão mais recente do AWS Command Line Interface (AWS CLI). ## Instalação do eksctl Siga as etapas descritas em [Instalar o kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) para instalar a versão mais recente do eksctl. Se você estiver usando a versão 1.22 ou versões posteriores do Kubernetes para o cluster do Amazon EKS, use uma versão do eksctl superior a 0.117.0. ## Cluster Amazon EKS Crie um cluster do Amazon EKS. Registre o cluster como um cluster virtual com o Amazon EMR no EKS. Confira abaixo os requisitos e as considerações para este cluster: + O cluster deve estar na mesma Amazon Virtual Private Cloud (VPC) que seu EMR Studio. + O cluster deve ter, no mínimo, uma sub-rede privada para ativar os endpoints interativos, vincular repositórios baseados em Git e iniciar o Application Load Balancer no modo privado. + Deve existir, no mínimo, uma sub-rede privada em comum entre o EMR Studio e o cluster do Amazon EKS usado para registrar o cluster virtual. Isso garante que seu endpoint interativo apareça como uma opção nos WorkSpaces do Studio e ativa a conectividade do Studio com o Application Load Balancer. Existem dois métodos que você pode escolher para conectar o Studio e o cluster do Amazon EKS: + Criar um cluster do Amazon EKS e associá-lo às sub-redes que pertencem ao seu EMR Studio. + Como alternativa, crie um EMR Studio e especifique as sub-redes privadas para o cluster do Amazon EKS. + ARM otimizado para Amazon EKS O Amazon Linux não é AMIs compatível com o Amazon EMR em endpoints interativos EKS. + Somente [grupos de nós gerenciados pelo Amazon EKS e nós](https://docs.aws.amazon.com/eks/latest/userguide/managed-node-groups.html) provisionados do Karpenter são suportados. ## Concessão de acesso ao cluster para o Amazon EMR no EKS Use as etapas em [Concessão de acesso ao cluster para o Amazon EMR no EKS](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/setting-up-cluster-access.html) para conceder acesso a um namespace específico em seu cluster para o Amazon EMR no EKS. ## Ativação de IRSA no cluster do Amazon EKS Para ativar os perfis do IAM para contas de serviço (IRSA) no cluster do Amazon EKS, siga as etapas em [Habilitação de perfis do IAM para contas de serviço (IRSA)](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/setting-up-enable-IAM.html). ## Criação de um perfil de execução de trabalho do IAM Você deve criar um perfil do IAM para executar workloads em endpoints interativos do Amazon EMR no EKS. Referimo-nos a esse perfil do IAM como *perfil de execução de trabalho* nesta documentação. Esse perfil do IAM é atribuído ao contêiner de endpoint interativo e aos contêineres de execução reais criados quando você envia trabalhos com o EMR Studio. Você precisará do nome do recurso da Amazon (ARN) do seu perfil de execução de trabalho para o Amazon EMR no EKS. Para isso, são necessárias duas etapas: + [Crie um perfil do IAM para execução de trabalhos.](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/creating-job-execution-role.html) + [Atualize a política de confiança do perfil de execução de trabalho.](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/setting-up-trust-policy.html) ## Concessão de acesso ao Amazon EMR no EKS para os usuários A entidade do IAM (usuário ou perfil) que faz a solicitação para criar um endpoint interativo também deve ter as permissões do Amazon EC2 e de `emr-containers` apresentadas a seguir. Siga as etapas descritas em [Concessão de acesso ao Amazon EMR no EKS para os usuários](setting-up-iam.md) para conceder as permissões que permitem que o Amazon EMR no EKS crie, gerencie e exclua os grupos de segurança que limitam o tráfego de entrada para o balanceador de carga do seu endpoint interativo. As seguintes permissões de `emr-containers` permitem que o usuário execute operações básicas do endpoint interativo: ``` "ec2:CreateSecurityGroup", "ec2:DeleteSecurityGroup", "ec2:AuthorizeSecurityGroupEgress", "ec2:AuthorizeSecurityGroupIngress", "ec2:RevokeSecurityGroupEgress", "ec2:RevokeSecurityGroupIngress" "emr-containers:CreateManagedEndpoint", "emr-containers:ListManagedEndpoints", "emr-containers:DescribeManagedEndpoint", "emr-containers:DeleteManagedEndpoint" ``` ## Registro do cluster do Amazon EKS com o Amazon EMR Configure um cluster virtual e mapeie-o para o namespace no cluster do Amazon EKS no qual você deseja executar os trabalhos. Para clusters AWS Fargate somente, use o mesmo namespace para o Amazon EMR no cluster virtual EKS e para o perfil Fargate. Para obter informações sobre como configurar um cluster virtual do Amazon EMR no EKS, consulte [Registro do cluster do Amazon EKS com o Amazon EMR](setting-up-registration.md). ## Implemente AWS o Load Balancer Controller no cluster Amazon EKS É necessário um AWS Application Load Balancer para seu cluster Amazon EKS. Você precisa configurar somente um controlador do Application Load Balancer por cluster do Amazon EKS. Para obter informações sobre como configurar o controlador do AWS Application Load Balancer, consulte [Instalando o complemento Load AWS Balancer Controller](https://docs.aws.amazon.com/eks/latest/userguide/aws-load-balancer-controller.html) no Guia do usuário *do Amazon* EKS. # Criação de um endpoint interativo para o cluster virtual Este tópico descreve algumas maneiras de criar um endpoint interativo usando a interface de linha de AWS comando (AWS CLI) e inclui detalhes sobre os parâmetros de configuração disponíveis. ## Criação de um endpoint interativo com o comando `create-managed-endpoint` Especifique os parâmetros no comando `create-managed-endpoint`, conforme apresentado a seguir. O Amazon EMR no EKS oferece suporte à criação de endpoints interativos com as versões 6.7.0 e superiores do Amazon EMR. ``` aws emr-containers create-managed-endpoint \ ‐‐type JUPYTER_ENTERPRISE_GATEWAY \ ‐‐virtual‐cluster‐id 1234567890abcdef0xxxxxxxx \ ‐‐name example-endpoint-name \ ‐‐execution-role-arn arn:aws:iam::444455556666:role/JobExecutionRole \ ‐‐release-label emr-6.9.0-latest \ ‐‐configuration-overrides '{ "applicationConfiguration": [{ "classification": "spark-defaults", "properties": { "spark.driver.memory": "2G" } }], "monitoringConfiguration": { "cloudWatchMonitoringConfiguration": { "logGroupName": "log_group_name", "logStreamNamePrefix": "log_stream_prefix" }, "persistentAppUI": "ENABLED", "s3MonitoringConfiguration": { "logUri": "s3://my_s3_log_location" } } }' ``` Para obter mais informações, consulte [Parâmetros para a criação de um endpoint interativo](#parameters-for-creating). ## Criação de um endpoint interativo com parâmetros especificados em um arquivo JSON 1. Crie um arquivo `create-managed-endpoint-request.json` e especifique os parâmetros obrigatórios para o endpoint, conforme mostrado no seguinte arquivo JSON: ``` { "name": "MY_TEST_ENDPOINT", "virtualClusterId": "MY_CLUSTER_ID", "type": "JUPYTER_ENTERPRISE_GATEWAY", "releaseLabel": "emr-6.9.0-latest", "executionRoleArn": "arn:aws:iam::444455556666:role/JobExecutionRole", "configurationOverrides": { "applicationConfiguration": [ { "classification": "spark-defaults", "properties": { "spark.driver.memory": "8G" } } ], "monitoringConfiguration": { "persistentAppUI": "ENABLED", "cloudWatchMonitoringConfiguration": { "logGroupName": "my_log_group", "logStreamNamePrefix": "log_stream_prefix" }, "s3MonitoringConfiguration": { "logUri": "s3://my_s3_log_location" } } } } ``` 1. Use o comando `create-managed-endpoint` com um caminho para o arquivo `create-managed-endpoint-request.json` armazenado localmente ou no Amazon S3. ``` aws emr-containers create-managed-endpoint \ ‐‐cli-input-json file://./create-managed-endpoint-request.json ‐‐region AWS-Region ``` ## Saída da criação de endpoint interativo Você deverá visualizar a saída a seguir no terminal. A saída inclui o nome e o identificador do seu novo endpoint interativo: ``` { "id": "1234567890abcdef0", "name": "example-endpoint-name", "arn": "arn:aws:emr-containers:us-west-2:111122223333:/virtualclusters/444455556666/endpoints/444455556666", "virtualClusterId": "111122223333xxxxxxxx" } ``` A execução de `aws emr-containers create-managed-endpoint` cria um certificado autoassinado que permite a comunicação HTTPS entre o EMR Studio e o servidor do endpoint interativo. Se você executar `create-managed-endpoint` e não tiver concluído os pré-requisitos, o Amazon EMR retornará uma mensagem de erro com as ações que você deve realizar para continuar. ## Parâmetros para a criação de um endpoint interativo **Topics** + [Parâmetros obrigatórios para endpoints interativos](#parameters-for-creating-required) + [Parâmetros opcionais para endpoints interativos](#parameters-for-creating-optional) ### Parâmetros obrigatórios para endpoints interativos Você deve especificar os seguintes parâmetros ao criar um endpoint interativo: **`‐‐type`** Use `JUPYTER_ENTERPRISE_GATEWAY`. Este é o único tipo com suporte. **`‐‐virtual-cluster-id`** O identificador do cluster virtual registrado com o Amazon EMR no EKS. **`‐‐name`** Um nome descritivo para o endpoint interativo que auxilia os usuários do EMR Studio a selecioná-lo na lista suspensa. **`‐‐execution-role-arn`** O nome do recurso da Amazon (ARN) do perfil de execução de trabalho do IAM para o Amazon EMR no EKS que foi criado como parte dos pré-requisitos. **`‐‐release-label`** O rótulo da versão do Amazon EMR a ser usado para o endpoint. Por exemplo, .`emr-6.9.0-latest` O Amazon EMR no EKS oferece suporte a endpoints interativos com as versões 6.7.0 e superiores do Amazon EMR. ### Parâmetros opcionais para endpoints interativos Como opção, também é possível especificar os seguintes parâmetros ao criar um endpoint interativo: **`‐‐configuration-overrides`** Para substituir as configurações padrão das aplicações, forneça um objeto de configuração. Você pode usar uma sintaxe abreviada para fornecer a configuração ou fazer referência ao objeto de configuração em um arquivo JSON. Os objetos de configuração consistem em uma classificação, propriedades e configurações opcionais aninhadas As propriedades consistem nas configurações que você deseja substituir neste arquivo. Você pode especificar várias classificações para diversas aplicações em um único objeto JSON. As classificações de configuração disponíveis variam de acordo com a versão do Amazon EMR no EKS. Para obter uma lista das classificações de configuração disponíveis para cada versão do Amazon EMR no EKS, consulte [Versões do Amazon EMR no EKS](emr-eks-releases.md). Além das classificações de configuração listadas para cada versão, os endpoints interativos trazem a classificação adicional `jeg-config`. Para obter mais informações, consulte [Opções de configuração do Jupyter Enterprise Gateway (JEG)](jeg-config-options.md). # Definição de configurações para endpoints interativos Esta seção contém uma série de tópicos que abrangem várias configurações para endpoints interativos e configurações de pod. Eles permitem monitorar e solucionar falhas, enviar informações de log para o Amazon S3 ou Amazon CloudWatch Logs para, ou criar endpoints interativos nos quais você especifica modelos de pod personalizados. **Topics** + [Monitorar trabalhos Spark do](monitoring-spark-jobs.md) + [Especificação de modelos de pod personalizados com endpoints interativos](custom-pod-templates.md) + [Implantação de um pod do JEG em um grupo de nós](managed-endpoint-nodegroups-setup.md) + [Opções de configuração do Jupyter Enterprise Gateway (JEG)](jeg-config-options.md) + [Modificando os parâmetros PySpark da sessão](modify-pyspark-parameters.md) + [Imagem de kernel personalizada com o endpoint interativo](custom-kernel.md) # Monitorar trabalhos Spark do Para que você possa monitorar e solucionar falhas, configure seus endpoints interativos para que os trabalhos iniciados com o endpoint possam enviar informações de log para o Amazon S3, Amazon CloudWatch Logs ou ambos. As seções a seguir descrevem como enviar logs de aplicações do Spark para o Amazon S3 para os trabalhos do Spark executados com endpoints interativos do Amazon EMR no EKS. **Configuração da política do IAM para os logs do Amazon S3** Antes que seus kernels possam enviar dados de log ao Amazon S3, a política de permissões para o perfil de execução de trabalho deve incluir as permissões apresentadas a seguir. Substitua *amzn-s3-demo-destination-bucket* pelo nome do bucket de registro em log. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Action": [ "s3:PutObject", "s3:GetObject", "s3:ListBucket" ], "Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket", "arn:aws:s3:::amzn-s3-demo-bucket/*" ], "Sid": "AllowS3Putobject" } ] } ``` ------ **nota** O Amazon EMR no EKS também pode criar um bucket do S3. Se um bucket do S3 não estiver disponível, inclua a permissão `s3:CreateBucket` na política do IAM. Após conceder as permissões necessárias para o envio de logs ao bucket do S3 ao perfil de execução, os dados de log serão enviados para os locais do Amazon S3 apresentados a seguir. Isso acontece quando `s3MonitoringConfiguration` é transferido na seção `monitoringConfiguration` de uma solicitação `create-managed-endpoint`. + **Logs de driver**: `logUri/virtual-cluster-id/endpoints/endpoint-id/containers/spark-application-id/spark-application-id-driver/(stderr.gz/stdout.gz)`. + **Logs de executor**: `logUri/virtual-cluster-id/endpoints/endpoint-id/containers/spark-application-id/executor-pod-name-exec-/(stderr.gz/stdout.gz)`. **nota** O Amazon EMR no EKS não faz o upload dos logs do endpoint para o bucket do S3. # Especificação de modelos de pod personalizados com endpoints interativos É possível criar endpoints interativos nos quais você especifica modelos de pod personalizados para drivers e executores. Os *modelos de pod* são especificações que determinam como ocorrerá a execução de cada pod. Você pode usar arquivos de modelo de pod para definir as configurações de pods de drivers ou de executores para as quais as configurações do Spark não oferecem suporte. No momento, os modelos de pod são compatíveis com as versões 6.3.0 e posteriores do Amazon EMR. Para obter mais informações sobre modelos de pod, consulte [Using pod templates](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/pod-templates.html) no *Guia de desenvolvimento do Amazon EMR no EKS*. O seguinte exemplo mostra como criar um endpoint interativo com modelos de pod: ``` aws emr-containers create-managed-endpoint \ --type JUPYTER_ENTERPRISE_GATEWAY \ --virtual-cluster-id virtual-cluster-id \ --name example-endpoint-name \ --execution-role-arn arn:aws:iam::aws-account-id:role/EKSClusterRole \ --release-label emr-6.9.0-latest \ --configuration-overrides '{ "applicationConfiguration": [ { "classification": "spark-defaults", "properties": { "spark.kubernetes.driver.podTemplateFile": "path/to/driver/template.yaml", "spark.kubernetes.executor.podTemplateFile": "path/to/executor/template.yaml" } }] }' ``` # Implantação de um pod do JEG em um grupo de nós O posicionamento do pod do JEG (Jupyter Enterprise Gateway) é um recurso que permite implantar um endpoint interativo em um grupo de nós específico. Com esse recurso, você pode definir configurações, como `instance type`, para o endpoint interativo. ## Associação de um pod do JEG a um grupo de nós gerenciado A propriedade de configuração apresentada a seguir permite especificar o nome de um grupo de nós gerenciado no cluster do Amazon EKS em que o pod do JEG será implantado. ``` //payload --configuration-overrides '{ "applicationConfiguration": [ { "classification": "endpoint-configuration", "properties": { "managed-nodegroup-name": NodeGroupName } } ] }' ``` Um grupo de nós deve ter o rótulo `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` do Kubernetes anexado a todos os nós que fazem parte do grupo de nós. Para listar todos os nós de um grupo de nós que têm essa etiqueta, use o seguinte comando: ``` kubectl get nodes --show-labels | grep for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName ``` Se a saída do comando acima não retornar nós que fazem parte do seu grupo de nós gerenciado, então não há nós no grupo de nós que tenham o rótulo `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` do Kubernetes anexado. Nesse caso, siga as etapas abaixo para anexar esse rótulo aos nós do seu grupo de nós. 1. Use o comando a seguir para adicionar o rótulo `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` do Kubernetes a todos os nós em um grupo de nós gerenciado `NodeGroupName`: ``` kubectl label nodes --selector eks:nodegroup-name=NodeGroupName for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName ``` 1. Verifique se os nós foram rotulados corretamente usando o seguinte comando: ``` kubectl get nodes --show-labels | grep for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName ``` Um grupo de nós gerenciado deve estar associado a um grupo de segurança do cluster do Amazon EKS, o que geralmente acontece se você criou o cluster e o grupo de nós gerenciado usando `eksctl`. Você pode verificar isso no AWS console usando as etapas a seguir. 1. Acesse o cluster no console do Amazon EKS. 1. Acesse a guia de redes do cluster e anote o grupo de segurança do cluster. 1. Acesse a guia de computação do seu cluster e clique no nome do grupo de nós gerenciado. 1. Na guia **Detalhes** do grupo de nós gerenciado, verifique se o grupo de segurança do cluster anotado anteriormente está listado em **Grupos de segurança**. Se o grupo de nós gerenciado não estiver anexado ao grupo de segurança do cluster do Amazon EKS, será necessário anexar a etiqueta `for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName` ao grupo de segurança do grupo de nós. Use as etapas abaixo para anexar essa etiqueta. 1. Acesse o console do Amazon EC2 e clique em grupos de segurança no painel de navegação à esquerda. 1. Selecione o grupo de segurança do seu grupo de nós gerenciado ao clicar na caixa de seleção. 1. Na guia **Etiquetas**, adicione a etiqueta `for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName` usando o botão **Gerenciar etiquetas**. ## Associação de um pod do JEG a um grupo de nós autogerenciado A propriedade de configuração apresentada a seguir permite especificar o nome de um grupo de nós autogerenciado ou não gerenciado no cluster do Amazon EKS em que o pod do JEG será implantado. ``` //payload --configuration-overrides '{ "applicationConfiguration": [ { "classification": "endpoint-configuration", "properties": { "self-managed-nodegroup-name": NodeGroupName } } ] }' ``` O grupo de nós deve ter o rótulo `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` do Kubernetes anexado a todos os nós que fazem parte do grupo de nós. Para listar todos os nós de um grupo de nós que têm essa etiqueta, use o seguinte comando: ``` kubectl get nodes --show-labels | grep for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName ``` Se a saída do comando acima não retornar nós que fazem parte do seu grupo de nós autogerenciado, então não há nós no grupo de nós que tenham o rótulo `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` do Kubernetes anexado. Nesse caso, siga as etapas abaixo para anexar esse rótulo aos nós do seu grupo de nós. 1. Se você criou o grupo de nós autogerenciado usando `eksctl`, use o comando a seguir para adicionar o rótulo `for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName` do Kubernetes a todos os nós no grupo de nós autogerenciado `NodeGroupName` de uma vez só. ``` kubectl label nodes --selector alpha.eksctl.io/nodegroup-name=NodeGroupName for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName ``` Caso não tenha usado `eksctl` para criar o grupo de nós autogerenciado, você precisará substituir o seletor no comando acima por um rótulo diferente do Kubernetes que esteja anexado a todos os nós do grupo de nós. 1. Use o seguinte comando para verificar se os nós foram rotulados corretamente: ``` kubectl get nodes --show-labels | grep for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName ``` O grupo de segurança do grupo de nós autogerenciado deve ter a etiqueta `for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName` anexada. Use as etapas apresentadas a seguir para anexar a etiqueta ao grupo de segurança do Console de gerenciamento da AWS. 1. Navegue até o console do Amazon EC2. Selecione **Grupos de segurança** no painel de navegação à esquerda. 1. Selecione a caixa de seleção ao lado do grupo de segurança do seu grupo de nós autogerenciado. 1. Na guia **Etiquetas**, use o botão **Gerenciar etiquetas** para adicionar a etiqueta `for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName`. Substitua `ClusterName` e `NodeGroupName` com os valores apropriados. ## Associação de um pod do JEG a um grupo de nós gerenciado com instâncias sob demanda Você também pode definir rótulos adicionais, conhecidos como *seletores de rótulos do Kubernetes*, para especificar limitações ou restrições adicionais à execução de um endpoint interativo em um determinado nó ou grupo de nós. O exemplo a seguir mostra como usar as instâncias sob demanda do Amazon EC2 para um pod do JEG. ``` --configuration-overrides '{ "applicationConfiguration": [ { "classification": "endpoint-configuration", "properties": { "managed-nodegroup-name": NodeGroupName, "node-labels": "eks.amazonaws.com/capacityType:ON_DEMAND" } } ] }' ``` **nota** Você pode usar a propriedade `node-labels` somente com uma propriedade `managed-nodegroup-name` ou `self-managed-nodegroup-name`. # Opções de configuração do Jupyter Enterprise Gateway (JEG) O Amazon EMR no EKS usa o Jupyter Enterprise Gateway (JEG) para ativar os endpoints interativos. É possível definir os valores a seguir para as configurações do JEG listadas como permitidas ao criar o endpoint. + **`RemoteMappingKernelManager.cull_idle_timeout`**: tempo limite em segundos (inteiro), após o qual um kernel é considerado inativo e pronto para ser descartado. Valores iguais ou inferiores a `0` desativam o descarte. Tempos limite curtos podem resultar no descarte de kernels para usuários com conexões de rede ruins. + **`RemoteMappingKernelManager.cull_interval`**: o intervalo em segundos (inteiro) no qual verificar se há kernels inativos que excedem o valor do tempo limite de descarte. # Modificando os parâmetros PySpark da sessão Começando com o Amazon EMR no EKS versão 6.9.0, no Amazon EMR Studio você pode ajustar a configuração do Spark associada a uma PySpark sessão executando o comando `%%configure` mágico na célula do notebook EMR. O exemplo a seguir mostra uma carga útil de exemplo que você pode usar para modificar a memória, os núcleos e outras propriedades do driver e do executor do Spark. Para as configurações `conf`, você pode definir qualquer configuração do Spark mencionada na [documentação de configuração do Apache Spark](https://spark.apache.org/docs/latest/configuration.html). ``` %%configure -f { "driverMemory": "16G", "driverCores": 4, "executorMemory" : "32G", "executorCores": 2, "conf": { "spark.dynamicAllocation.maxExecutors" : 10, "spark.dynamicAllocation.minExecutors": 1 } } ``` O exemplo a seguir mostra uma carga útil de exemplo que você pode usar para adicionar arquivos, pyFiles e dependências em JAR a um runtime do Spark. ``` %%configure -f { "files": "s3://amzn-s3-demo-bucket-emr-eks/sample_file.txt", "pyFiles": : "path-to-python-files", "jars" : "path-to-jars } ``` # Imagem de kernel personalizada com o endpoint interativo Para garantir que você tenha as dependências corretas para sua aplicação ao executar as workloads interativas do Amazon EMR Studio, você pode personalizar as imagens do Docker para os endpoints interativos e executar imagens base de kernel personalizadas. Para criar um endpoint interativo e conectá-lo a uma imagem do Docker personalizada, execute as etapas a seguir. **nota** Você pode substituir somente as imagens base. Não é possível adicionar novos tipos de imagens de kernel. 1. **Crie e publique uma imagem do Docker personalizada.** A imagem base contém o runtime do Spark e os kernels do caderno que são executados com ele. Para criar a imagem, você pode seguir as etapas de 1 a 4 descritas em [Como personalizar imagens do Docker](docker-custom-images-steps.md). Na etapa 1, o URI da imagem base em seu arquivo do Docker deve usar `notebook-spark` no lugar de `spark`. ``` ECR-registry-account.dkr.ecr.Region.amazonaws.com/notebook-spark/container-image-tag ``` Para obter mais informações sobre como selecionar Regiões da AWS e armazenar tags de imagem, consulte[Detalhes sobre como selecionar um URI de imagem base](docker-custom-images-tag.md). 1. **Crie um endpoint interativo que possa ser usado com a imagem personalizada.** 1. Crie um arquivo JSON `custom-image-managed-endpoint.json` com o conteúdo apresentado a seguir. Este exemplo usa a versão 6.9.0 do Amazon EMR. **Example** ``` { "name": "endpoint-name", "virtualClusterId": "virtual-cluster-id", "type": "JUPYTER_ENTERPRISE_GATEWAY", "releaseLabel": "emr-6.9.0-latest", "executionRoleArn": "execution-role-arn", "configurationOverrides": { "applicationConfiguration": [ { "classification": "jupyter-kernel-overrides", "configurations": [ { "classification": "python3", "properties": { "container-image": "123456789012.dkr.ecr.us-west-2.amazonaws.com/custom-notebook-python:latest" } }, { "classification": "spark-python-kubernetes", "properties": { "container-image": "123456789012.dkr.ecr.us-west-2.amazonaws.com/custom-notebook-spark:latest" } } ] } ] } } ``` 1. Crie um endpoint interativo com as configurações especificadas no arquivo JSON, conforme mostrado no exemplo a seguir. Para obter mais informações, consulte [Criação de um endpoint interativo com o comando `create-managed-endpoint`](create-managed-endpoint.md#create-using-json-file). ``` aws emr-containers create-managed-endpoint --cli-input-json custom-image-managed-endpoint.json ``` 1. **Conecte-se ao endpoint interativo usando o EMR Studio.** Para obter mais informações e etapas a serem concluídas, consulte [Conectando-se do Studio](https://emr-on-eks.workshop.aws/advanced/emr-studio/connecting-from-studio.html) na seção Amazon EMR no EKS dos documentos do AWS Workshop Studio. # Monitoramento de endpoints interativos Com o Amazon EMR no EKS versão 6.10 e posterior, os endpoints interativos emitem métricas da CloudWatch Amazon para monitorar e solucionar problemas nas operações do ciclo de vida do kernel. As métricas são acionadas por clientes interativos, como o EMR Studio ou os cadernos Jupyter de hospedagem própria. Cada uma das operações compatíveis com os endpoints interativos tem métricas associadas a elas. As operações são modeladas como dimensões para cada métrica, conforme mostrado na tabela abaixo. As métricas emitidas por endpoints interativos são visíveis em um namespace personalizado, EMRContainers, em sua conta. | Métrica | Description | Unidade | | --- | --- | --- | | RequestCount | Número cumulativo de solicitações de uma operação processada pelo endpoint interativo. | Contagem | | RequestLatency | O horário entre uma solicitação chegar ao endpoint interativo e uma resposta ser enviada pelo endpoint interativo. | Milissegundo | | 4 XXError | Emitido quando uma solicitação de uma operação resulta em um erro 4xx durante o processamento. | Contagem | | 5XXError | Emitido quando uma solicitação de uma operação resulta em um erro 5Xxx no lado do servidor. | Contagem | | KernelLaunchSuccess | Aplicável somente para a CreateKernel operação. Indica o número cumulativo de inicializações de kernel que ocorreram com êxito até e incluindo esta solicitação. | Contagem | | KernelLaunchFailure | Aplicável somente para a CreateKernel operação. Indica o número cumulativo de falhas de inicialização de kernel até e incluindo esta solicitação. | Contagem | Cada métrica do endpoint interativo tem as seguintes dimensões anexadas a ela: + **`ManagedEndpointId`**: identificador para o endpoint interativo. + **`OperationName`**: a operação acionada pelo cliente interativo. Os valores possíveis para a dimensão **`OperationName`** são mostrados na seguinte tabela: | `operationName` | Descrição da operação | | --- | --- | | `CreateKernel` | Solicita que o endpoint interativo inicie um kernel. | | `ListKernels` | Solicita que o endpoint interativo liste os kernels que foram iniciados anteriormente usando o mesmo token de sessão. | | `GetKernel` | Solicita que o endpoint interativo obtenha detalhes sobre um kernel específico que foi iniciado anteriormente. | | `ConnectKernel` | Solicita que o endpoint interativo estabeleça conectividade entre o cliente do caderno e o kernel. | | `ConfigureKernel` | Publica `%%configure magic request` em um kernel do PySpark. | | `ListKernelSpecs` | Solicita que o endpoint interativo liste as especificações de kernel disponíveis. | | `GetKernelSpec` | Solicita que o endpoint interativo obtenha as especificações de kernel de um kernel que foi iniciado anteriormente. | | `GetKernelSpecResource` | Solicita que o endpoint interativo obtenha recursos específicos associados às especificações do kernel que foram iniciadas anteriormente. | ## Exemplos ### Para acessar o número total de kernels iniciados para um endpoint interativo em um determinado dia: 1. Selecione o namespace personalizado: `EMRContainers`. 1. Selecione o `ManagedEndpointId` e `OperationName – CreateKernel`. 1. A métrica `RequestCount` com a estatística `SUM` e o período de `1 day` fornecerá todas as solicitações de inicialização do kernel realizadas nas últimas 24 horas. 1. KernelLaunchSuccess A métrica com estatística `SUM` e período `1 day` fornecerá todas as solicitações bem-sucedidas de inicialização do kernel feitas nas últimas 24 horas. ### Para acessar o número de falhas de kernel para um endpoint interativo em um determinado dia: 1. Selecione o namespace personalizado: EMRContainers 1. Selecione o `ManagedEndpointId` e `OperationName – CreateKernel`. 1. A métrica `KernelLaunchFailure` com a estatística `SUM` e o período de `1 day` fornecerá todas as solicitações de inicialização do kernel com falha realizadas nas últimas 24 horas. Você também pode selecionar as métricas `4XXError` e `5XXError` para saber que tipo de falha na inicialização do kernel ocorreu. # Uso de cadernos Jupyter de hospedagem própria *Você pode hospedar e gerenciar o Jupyter ou JupyterLab notebooks em uma instância do Amazon EC2 ou em seu próprio cluster Amazon EKS como um notebook Jupyter auto-hospedado.* Em seguida, é possível executar workloads interativas com seus cadernos Jupyter de hospedagem própria. As seções apresentadas a seguir descrevem o processo de configuração e de implantação de um caderno Jupyter de hospedagem própria em um cluster do Amazon EKS. **Topics** + [Criar um grupo de segurança](#managed-endpoints-self-hosted-security) + [Criação de um endpoint interativo do Amazon EMR no EKS](#managed-endpoints-self-hosted-create-me) + [Recuperação do URL do servidor de gateway do endpoint interativo](#managed-endpoints-self-hosted-gateway) + [Recuperação de um token de autenticação para a conexão com o endpoint interativo](#managed-endpoints-self-hosted-auth) + [Exemplo: implantar um JupyterLab notebook](#managed-endpoints-self-hosted-example) + [Exclusão de um caderno Jupyter de hospedagem própria](#managed-endpoints-self-hosted-cleanup) ## Criar um grupo de segurança Antes de criar um endpoint interativo e executar um Jupyter ou JupyterLab notebook auto-hospedado, você deve criar um grupo de segurança para controlar o tráfego entre seu notebook e o endpoint interativo. Para usar o console do Amazon EC2 ou o SDK do Amazon EC2 para criar o grupo de segurança, consulte as etapas em [Create a security group](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-security-groups.html#creating-security-group) no *Guia do usuário do Amazon EC2*. Você deve criar o grupo de segurança na VPC em que deseja implantar seu servidor de cadernos. Para seguir o exemplo deste guia, use a mesma VPC do cluster do Amazon EKS. Se você quiser hospedar seu notebook em uma VPC diferente da VPC do seu cluster Amazon EKS, talvez seja necessário criar uma conexão de emparelhamento entre essas duas. VPCs Para ver as etapas para criar uma conexão de emparelhamento entre duas VPCs, consulte [Criar uma conexão de emparelhamento de VPC](https://docs.aws.amazon.com/vpc/latest/peering/create-vpc-peering-connection.html) no Amazon VPC Getting Started Guide. Você precisará do ID do grupo de segurança para [criar um endpoint interativo do Amazon EMR no EKS](https://docs.aws.amazon.com/) na próxima etapa. ## Criação de um endpoint interativo do Amazon EMR no EKS Após criar o grupo de segurança para o seu caderno, use as etapas fornecidas em [Criação de um endpoint interativo para o cluster virtual](create-managed-endpoint.md) para criar um endpoint interativo. Você deve fornecer o ID do grupo de segurança criado para o seu caderno em [Criar um grupo de segurança](#managed-endpoints-self-hosted-security). Insira o ID de segurança no lugar das *your-notebook-security-group-id* seguintes configurações de substituição de configuração: ``` --configuration-overrides '{ "applicationConfiguration": [ { "classification": "endpoint-configuration", "properties": { "notebook-security-group-id": "your-notebook-security-group-id" } } ], "monitoringConfiguration": { ...' ``` ## Recuperação do URL do servidor de gateway do endpoint interativo Após criar um endpoint interativo, recupere o URL do servidor de gateway usando o comando `describe-managed-endpoint` na AWS CLI. Você precisa desse URL para conectar seu caderno ao endpoint. O URL do servidor de gateway é um endpoint privado. ``` aws emr-containers describe-managed-endpoint \ --region region \ --virtual-cluster-id virtualClusterId \ --id endpointId ``` Inicialmente, seu endpoint está no estado **CREATING**. Após alguns minutos, ele passa para o estado **ACTIVE**. Quando o endpoint estiver **ACTIVE**, ele estará pronto para uso. Anote o atributo `serverUrl` que o comando `aws emr-containers describe-managed-endpoint` retorna do endpoint ativo. Você precisa dessa URL para conectar seu notebook ao endpoint ao [implantar seu Jupyter ou notebook auto-hospedado](https://docs.aws.amazon.com/). JupyterLab ## Recuperação de um token de autenticação para a conexão com o endpoint interativo Para se conectar a um endpoint interativo a partir de um Jupyter ou JupyterLab notebook, você deve gerar um token de sessão com a API. `GetManagedEndpointSessionCredentials` O token atua como prova de autenticação para a conexão com o servidor de endpoint interativo. O comando apresentado a seguir é explicado com mais detalhes com um exemplo de saída abaixo. ``` aws emr-containers get-managed-endpoint-session-credentials \ --endpoint-identifier endpointArn \ --virtual-cluster-identifier virtualClusterArn \ --execution-role-arn executionRoleArn \ --credential-type "TOKEN" \ --duration-in-seconds durationInSeconds \ --region region ``` **`endpointArn`** O ARN do seu endpoint. Você pode descobrir o ARN no resultado de uma chamada `describe-managed-endpoint`. **`virtualClusterArn`** O ARN do cluster virtual. **`executionRoleArn`** O ARN do perfil de execução. **`durationInSeconds`** A duração, em segundos, pela qual o token é válido. A duração padrão é de 15 minutos (`900`) e a duração máxima é de 12 horas (`43200`). **`region` ** A mesma região do seu endpoint. A saída deve ser semelhante ao exemplo apresentado a seguir. Anote o `session-token` valor que você usará ao [implantar seu Jupyter ou notebook auto-hospedado](https://docs.aws.amazon.com/). JupyterLab ``` { "id": "credentialsId", "credentials": { "token": "session-token" }, "expiresAt": "2022-07-05T17:49:38Z" } ``` ## Exemplo: implantar um JupyterLab notebook Depois de concluir as etapas acima, você pode tentar este procedimento de exemplo para implantar um JupyterLab notebook no cluster Amazon EKS com seu endpoint interativo. 1. Crie um namespace para executar o servidor de cadernos. 1. Crie um arquivo localmente, chamado `notebook.yaml`, com o conteúdo apresentado a seguir. O conteúdo para o arquivo é descrito abaixo. ``` apiVersion: v1 kind: Pod metadata: name: jupyter-notebook namespace: namespace spec: containers: - name: minimal-notebook image: jupyter/all-spark-notebook:lab-3.1.4 # open source image ports: - containerPort: 8888 command: ["start-notebook.sh"] args: ["--LabApp.token=''"] env: - name: JUPYTER_ENABLE_LAB value: "yes" - name: KERNEL_LAUNCH_TIMEOUT value: "400" - name: JUPYTER_GATEWAY_URL value: "serverUrl" - name: JUPYTER_GATEWAY_VALIDATE_CERT value: "false" - name: JUPYTER_GATEWAY_AUTH_TOKEN value: "session-token" ``` Se você estiver implantando o caderno Jupyter em um cluster somente do Fargate, rotule o pod do Jupyter com um rótulo `role`, conforme mostrado no seguinte exemplo: ``` ... metadata: name: jupyter-notebook namespace: default labels: role: example-role-name-label spec: ... ``` **`namespace`** O namespace do Kubernetes no qual o caderno é implantado. **`serverUrl`** O atributo `serverUrl` que o comando `describe-managed-endpoint` retornou em [Recuperação do URL do servidor de gateway do endpoint interativo](#managed-endpoints-self-hosted-gateway). **`session-token`** O atributo `session-token` que o comando `get-managed-endpoint-session-credentials` retornou em [Recuperação de um token de autenticação para a conexão com o endpoint interativo](#managed-endpoints-self-hosted-auth). **`KERNEL_LAUNCH_TIMEOUT`** A quantidade de tempo, em segundos, que o endpoint interativo aguarda até que o kernel chegue ao estado **RUNNING**. Garanta tempo suficiente para a inicialização do kernel ser concluída ao definir o tempo limite de inicialização do kernel para um valor apropriado (máximo de 400 segundos). **`KERNEL_EXTRA_SPARK_OPTS`** Como opção, você pode transferir configurações adicionais do Spark para os kernels do Spark. Defina essa variável de ambiente com os valores da propriedade de configuração do Spark, conforme mostrado no seguinte exemplo: ``` - name: KERNEL_EXTRA_SPARK_OPTS value: "--conf spark.driver.cores=2 --conf spark.driver.memory=2G --conf spark.executor.instances=2 --conf spark.executor.cores=2 --conf spark.executor.memory=2G --conf spark.dynamicAllocation.enabled=true --conf spark.dynamicAllocation.shuffleTracking.enabled=true --conf spark.dynamicAllocation.minExecutors=1 --conf spark.dynamicAllocation.maxExecutors=5 --conf spark.dynamicAllocation.initialExecutors=1 " ``` 1. Implante a especificação do pod no cluster do Amazon EKS: ``` kubectl apply -f notebook.yaml -n namespace ``` Isso iniciará um JupyterLab notebook mínimo conectado ao seu Amazon EMR no endpoint interativo EKS. Aguarde até que o pod esteja **RUNNING**. Você pode verificar seu status com o seguinte comando: ``` kubectl get pod jupyter-notebook -n namespace ``` Quando o pod estiver pronto, o comando `get pod` retornará uma saída semelhante a esta: ``` NAME READY STATUS RESTARTS AGE jupyter-notebook 1/1 Running 0 46s ``` 1. Anexe o grupo de segurança do caderno ao nó em que o caderno está programado. 1. Primeiro, identifique o nó em que o pod `jupyter-notebook` está programado com o comando `describe pod`. ``` kubectl describe pod jupyter-notebook -n namespace ``` 1. Abra o console do Amazon EKS em [https://console.aws.amazon.com/eks/home\$1/clusters](https://console.aws.amazon.com/eks/home#/clusters). 1. Navegue até a guia **Computação** do cluster do Amazon EKS e selecione o nó identificado pelo comando `describe pod`. Selecione o ID da instância para o nó. 1. No menu **Ações**, selecione **Segurança** > **Alterar grupos de segurança** para anexar o grupo de segurança que você criou em [Criar um grupo de segurança](#managed-endpoints-self-hosted-security). 1. Se você estiver implantando o pod do notebook Jupyter AWS Fargate, crie um []()para aplicar ao pod do notebook Jupyter com o rótulo de função: ``` cat >my-security-group-policy.yaml < val x = random * 2 - 1 val y = random * 2 - 1 if (x*x + y*y <= 1) 1 else 0 }.reduce(_ + _) println(s"Pi is roughly ${4.0 * count / (n - 1)}") session.stop() ``` ![\[Captura de tela do exemplo do código do notebook Scala em. JupyterLab\]](http://docs.aws.amazon.com/pt_br/emr/latest/EMR-on-EKS-DevelopmentGuide/images/emr-on-eks-Jupyter-notebook-scala-program.png) ## Exclusão de um caderno Jupyter de hospedagem própria Quando estiver com tudo pronto para excluir seu caderno de hospedagem própria, você também poderá excluir o endpoint interativo e o grupo de segurança. Execute as ações na seguinte ordem: 1. Use o seguinte comando para excluir o pod `jupyter-notebook`: ``` kubectl delete pod jupyter-notebook -n namespace ``` 1. Em seguida, exclua o endpoint interativo com o comando `delete-managed-endpoint`. Para obter as etapas para a exclusão de um endpoint interativo, consulte [Exclusão de um endpoint interativo](delete-managed-endpoint.md). Inicialmente, seu endpoint estará no estado **TERMINATING**. Depois que todos os recursos forem limpos, ele transitará para o estado **TERMINATED**. 1. Caso não planeje usar o grupo de segurança de cadernos criado em [Criar um grupo de segurança](#managed-endpoints-self-hosted-security) para outras implantações de caderno Jupyter, você poderá excluí-lo. Consulte [Excluir um grupo de segurança](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/working-with-security-groups.html#deleting-security-group) no Guia do usuário do Amazon EC2 para obter mais informações. # Como obter informações sobre endpoints interativos com comandos da CLI Este tópico aborda as operações com suporte em um endpoint interativo diferente de [`create-managed-endpoint`](create-managed-endpoint.md). ## Busca de detalhes do endpoint interativo Depois de criar um endpoint interativo, você pode recuperar seus detalhes usando o `describe-managed-endpoint` AWS CLI comando. Insira seus próprios valores para*managed-endpoint-id*,*virtual-cluster-id*, e*region*: ``` aws emr-containers describe-managed-endpoint ‐‐id managed-endpoint-id \ ‐‐virtual-cluster-id virtual-cluster-id ‐‐region region ``` A saída é semelhante à apresentada a seguir, com o endpoint especificado, como o ARN, o ID e o nome. ``` { "id": "as3ys2xxxxxxx", "name": "endpoint-name", "arn": "arn:aws:emr-containers:us-east-1:1828xxxxxxxx:/virtualclusters/lbhl6kwwyoxxxxxxxxxxxxxxx/endpoints/as3ysxxxxxxxx", "virtualClusterId": "lbhl6kwwyoxxxxxxxxxxxxxxx", "type": "JUPYTER_ENTERPRISE_GATEWAY", "state": "ACTIVE", "releaseLabel": "emr-6.9.0-latest", "executionRoleArn": "arn:aws:iam::1828xxxxxxxx:role/RoleName", "certificateAuthority": { "certificateArn": "arn:aws:acm:us-east-1:1828xxxxxxxx:certificate/zzzzzzzz-e59b-4ed0-aaaa-bbbbbbbbbbbb", "certificateData": "certificate-data" }, "configurationOverrides": { "applicationConfiguration": [ { "classification": "spark-defaults", "properties": { "spark.driver.memory": "8G" } } ], "monitoringConfiguration": { "persistentAppUI": "ENABLED", "cloudWatchMonitoringConfiguration": { "logGroupName": "log-group-name", "logStreamNamePrefix": "log-stream-name-prefix" }, "s3MonitoringConfiguration": { "logUri": "s3-bucket-name" } } }, "serverUrl": "https://internal-k8s-namespace-ingressa-aaaaaaaaaa-zzzzzzzzzz.us-east-1.elb.amazonaws.com:18888 (https://internal-k8s-nspluto-ingressa-51e860abbd-1620715833.us-east-1.elb.amazonaws.com:18888/)", "createdAt": "2022-09-19T12:37:49+00:00", "securityGroup": "sg-aaaaaaaaaaaaaa", "subnetIds": [ "subnet-11111111111", "subnet-22222222222", "subnet-33333333333" ], "stateDetails": "Endpoint created successfully. It took 3 Minutes 15 Seconds", "tags": {} } ``` ## Listagem de todos os endpoints interativos associados a um cluster virtual Use o `list-managed-endpoints` AWS CLI comando para obter uma lista de todos os endpoints interativos associados a um cluster virtual especificado. Substitua `virtual-cluster-id` pelo ID do seu cluster virtual. ``` aws emr-containers list-managed-endpoints ‐‐virtual-cluster-id virtual-cluster-id ``` A saída do comando `list-managed-endpoint` é mostrada abaixo: ``` { "endpoints": [{ "id": "as3ys2xxxxxxx", "name": "endpoint-name", "arn": "arn:aws:emr-containers:us-east-1:1828xxxxxxxx:/virtualclusters/lbhl6kwwyoxxxxxxxxxxxxxxx/endpoints/as3ysxxxxxxxx", "virtualClusterId": "lbhl6kwwyoxxxxxxxxxxxxxxx", "type": "JUPYTER_ENTERPRISE_GATEWAY", "state": "ACTIVE", "releaseLabel": "emr-6.9.0-latest", "executionRoleArn": "arn:aws:iam::1828xxxxxxxx:role/RoleName", "certificateAuthority": { "certificateArn": "arn:aws:acm:us-east-1:1828xxxxxxxx:certificate/zzzzzzzz-e59b-4ed0-aaaa-bbbbbbbbbbbb", "certificateData": "certificate-data" }, "configurationOverrides": { "applicationConfiguration": [{ "classification": "spark-defaults", "properties": { "spark.driver.memory": "8G" } }], "monitoringConfiguration": { "persistentAppUI": "ENABLED", "cloudWatchMonitoringConfiguration": { "logGroupName": "log-group-name", "logStreamNamePrefix": "log-stream-name-prefix" }, "s3MonitoringConfiguration": { "logUri": "s3-bucket-name" } } }, "serverUrl": "https://internal-k8s-namespace-ingressa-aaaaaaaaaa-zzzzzzzzzz.us-east-1.elb.amazonaws.com:18888 (https://internal-k8s-nspluto-ingressa-51e860abbd-1620715833.us-east-1.elb.amazonaws.com:18888/)", "createdAt": "2022-09-19T12:37:49+00:00", "securityGroup": "sg-aaaaaaaaaaaaaa", "subnetIds": [ "subnet-11111111111", "subnet-22222222222", "subnet-33333333333" ], "stateDetails": "Endpoint created successfully. It took 3 Minutes 15 Seconds", "tags": {} }] } ``` # Exclusão de um endpoint interativo Para excluir um endpoint interativo associado a um cluster virtual Amazon EMR no EKS, use `delete-managed-endpoint` AWS CLI o comando. Quando você exclui um endpoint interativo, o Amazon EMR no EKS remove os grupos de segurança padrão criados para esse endpoint. Especifique valores para os seguintes parâmetros do comando: + **‐‐id:** o identificador do endpoint interativo que você deseja excluir. + **‐‐ virtual-cluster-id** — O identificador do cluster virtual associado ao endpoint interativo que você deseja excluir. Esse é o mesmo ID do cluster virtual que foi especificado quando o endpoint interativo foi criado. ``` aws emr-containers delete-managed-endpoint ‐‐id managed-endpoint-id ‐‐virtual-cluster-id virtual-cluster-id ``` O comando retorna uma saída semelhante à seguinte para confirmar que você excluiu o endpoint interativo: ``` { "id":"8gai4l4exxxxx", "virtualClusterId":"0b0qvauoy3ch1nqodxxxxxxxx" } ```