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

# Uso de cadernos Jupyter de hospedagem própria
<a name="managed-endpoints-self-hosted"></a>

*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
<a name="managed-endpoints-self-hosted-security"></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
<a name="managed-endpoints-self-hosted-create-me"></a>

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
<a name="managed-endpoints-self-hosted-gateway"></a>

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
<a name="managed-endpoints-self-hosted-auth"></a>

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
<a name="managed-endpoints-self-hosted-example"></a>

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\#/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 <<EOF
      apiVersion: vpcresources.k8s.aws/v1beta1
      kind: SecurityGroupPolicy
      metadata:
        name: {{example-security-group-policy-name}}
        namespace: default
      spec:
        podSelector:
          matchLabels:
            role: {{example-role-name-label}}
        securityGroups:
          groupIds:
            - {{your-notebook-security-group-id}}
      EOF
      ```

1. Agora, encaminhe a porta para que você possa acessar localmente a JupyterLab interface:

   ```
   kubectl port-forward jupyter-notebook 8888:8888 -n {{namespace}}
   ```

   Quando estiver em execução, navegue até o navegador local e visite `localhost:8888` para ver a JupyterLab interface:  
![Captura de tela da tela JupyterLab inicial.](http://docs.aws.amazon.com/pt_br/emr/latest/EMR-on-EKS-DevelopmentGuide/images/emr-on-eks-Jupyter-notebook-start.png)

1.  JupyterLabEm, crie um novo notebook Scala. Confira um exemplo de trecho de código que você pode executar para aproximar o valor de Pi:

   ```
   import scala.math.random
   import org.apache.spark.sql.SparkSession
   
   /** Computes an approximation to pi */
   val session = SparkSession
     .builder
     .appName("Spark Pi")
     .getOrCreate()
   
   val slices = 2
   // avoid overflow
   val n = math.min(100000L * slices, Int.MaxValue).toInt 
    
   val count = session.sparkContext
   .parallelize(1 until n, slices)
   .map { i =>
     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
<a name="managed-endpoints-self-hosted-cleanup"></a>

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.