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 do Apache Livy com o Amazon EMR no EKS
<a name="job-runs-apache-livy"></a>

Com as versões 7.1.0 e posteriores do Amazon EMR, é possível usar o Apache Livy para enviar trabalhos no Amazon EMR no EKS. Usando o Apache Livy, você pode configurar seu próprio endpoint REST do Apache Livy e usá-lo para implantar e gerenciar aplicações do Spark em clusters do Amazon EKS. Após instalar o Livy no cluster do Amazon EKS, você poderá usar o endpoint do Livy para enviar aplicações do Spark ao servidor do Livy. O servidor gerencia o ciclo de vida das aplicações do Spark.

**nota**  
O Amazon EMR calcula preços no Amazon EKS com base no consumo de memória e vCPU. Esse cálculo se aplica aos pods de drivers e de executores. Esse cálculo começa quando você baixa a imagem da aplicação do Amazon EMR até que o pod do Amazon EKS seja encerrado e arredondado para o segundo mais próximo.

**Topics**
+ [Configuração do Apache Livy para o Amazon EMR no EKS](job-runs-apache-livy-setup.md)
+ [Conceitos básicos do Apache Livy para Amazon EMR no EKS](job-runs-apache-livy-install.md)
+ [Execução de uma aplicação do Spark com o Apache Livy para o Amazon EMR no EKS](job-runs-apache-livy-run-spark.md)
+ [Desinstalação do Apache Livy com o Amazon EMR no EKS](job-runs-apache-livy-uninstall.md)
+ [Segurança para o Apache Livy com o Amazon EMR no EKS](job-runs-apache-livy-security.md)
+ [Propriedades de instalação do Apache Livy em versões do Amazon EMR no EKS](job-runs-apache-livy-installation-properties.md)
+ [Solução de erros comuns de formato de variável de ambiente](job-runs-apache-livy-troubleshooting.md)

# Configuração do Apache Livy para o Amazon EMR no EKS
<a name="job-runs-apache-livy-setup"></a>

Antes de instalar o Apache Livy no cluster do Amazon EKS, é necessário instalar e configurar um conjunto de ferramentas de pré-requisitos. Isso inclui o AWS CLI, que é uma ferramenta de linha de comando fundamental para trabalhar com AWS recursos, ferramentas de linha de comando para trabalhar com o Amazon EKS e um controlador usado nesse caso de uso para disponibilizar seu aplicativo de cluster na Internet e rotear o tráfego de rede.
+ **[Instale ou atualize para a versão mais recente do AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)** — Se você já instalou o AWS CLI, confirme se você tem a versão mais recente.
+ **[Instale o kubectl e o eksctl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) **: o eksctl é uma ferramenta de linha de comando que você usa para se comunicar com o Amazon EKS.
+ **[Instale o Helm](https://docs.aws.amazon.com/eks/latest/userguide/helm.html)**: o gerenciador de pacotes Helm para o Kubernetes ajuda a instalar e gerenciar aplicações em seu cluster do Kubernetes. 
+ **[Comece a usar o Amazon EKS (eksctl):](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html) **siga as etapas para criar um cluster do Kubernetes com nós no Amazon EKS.
+ **[Selecione um rótulo de versão do Amazon EMR](docker-custom-images-tag.md)**: o Apache Livy é compatível com as versões 7.1.0 e superiores do Amazon EMR.
+ **[Instale o controlador ALB — o controlador](https://docs.aws.amazon.com/eks/latest/userguide/aws-load-balancer-controller.html)** ALB gerencia o AWS Elastic Load Balancing para clusters Kubernetes. Ele cria um AWS Network Load Balancer (NLB) quando você cria um Kubernetes Ingress enquanto configura o Apache Livy.

# Conceitos básicos do Apache Livy para Amazon EMR no EKS
<a name="job-runs-apache-livy-install"></a>

Conclua as etapas a seguir para instalar o Apache Livy. Eles incluem a configuração do gerenciador de pacotes, a criação de um namespace para executar workloads do Spark, a instalação do Livy, a configuração do balanceamento de carga e as etapas de verificação. Você precisa concluir essas etapas para executar um trabalho em lotes com o Spark.

1. Se ainda não tiver feito isso, configure o [Apache Livy para o Amazon EMR no EKS](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html).

1. Autentique seu cliente Helm no registro do Amazon ECR. Você pode encontrar o `ECR-registry-account` valor correspondente para suas [contas Região da AWS de registro do Amazon ECR por região](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/docker-custom-images-tag.html#docker-custom-images-ECR).

   ```
   aws ecr get-login-password \--region <AWS_REGION> | helm registry login \
   --username AWS \
   --password-stdin <ECR-registry-account>.dkr.ecr.<region-id>.amazonaws.com
   ```

1. A configuração do Livy cria uma conta de serviço para o servidor do Livy e outra conta para a aplicação do Spark. Para configurar o IRSA nas contas de serviço, consulte [Setting up access permissions with IAM roles for service accounts (IRSA)](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-irsa.html). 

1. Crie um namespace para executar as workloads do Spark.

   ```
   kubectl create ns <spark-ns>
   ```

1. Use o comando a seguir para instalar o Livy.

   Esse endpoint do Livy só está disponível internamente para a VPC no cluster do EKS. Para habilitar o acesso além da VPC, defina `—-set loadbalancer.internal=false` no comando de instalação do Helm.
**nota**  
Por padrão, o SSL não está habilitado nesse endpoint do Livy, e o endpoint só é visível dentro da VPC do cluster do EKS. Se você definir `loadbalancer.internal=false` e `ssl.enabled=false`, estará expondo um endpoint inseguro fora da sua VPC. Para configurar um endpoint seguro do Livy, consulte [Configuring a secure Apache Livy endpoint with TLS/SSL](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-secure-endpoint.html). 

   ```
   helm install livy-demo \
     oci://895885662937.dkr.ecr.region-id.amazonaws.com/livy \
     --version 7.12.0 \
     --namespace livy-ns \
     --set image=ECR-registry-account.dkr.ecr.region-id.amazonaws.com/livy/emr-7.12.0:latest \
     --set sparkNamespace=<spark-ns> \
     --create-namespace
   ```

   Você verá a saída a seguir.

   ```
   NAME: livy-demo
   LAST DEPLOYED: Mon Mar 18 09:23:23 2024
   NAMESPACE: livy-ns
   STATUS: deployed
   REVISION: 1
   TEST SUITE: None
   NOTES:
   The Livy server has been installed.
   Check installation status:
   1. Check Livy Server pod is running
     kubectl --namespace livy-ns get pods -l "app.kubernetes.io/instance=livy-demo"
   2. Verify created NLB is in Active state and it's target groups are healthy (if loadbalancer.enabled is true)
   
   Access LIVY APIs:
       # Ensure your NLB is active and healthy
       # Get the Livy endpoint using command:
       LIVY_ENDPOINT=$(kubectl get svc -n livy-ns -l app.kubernetes.io/instance=livy-demo,emr-containers.amazonaws.com/type=loadbalancer -o jsonpath='{.items[0].status.loadBalancer.ingress[0].hostname}' |  awk '{printf "%s:8998\n", $0}')
       # Access Livy APIs using http://$LIVY_ENDPOINT or https://$LIVY_ENDPOINT (if SSL is enabled)
       # Note: While uninstalling Livy, makes sure the ingress and NLB are deleted after running the helm command to avoid dangling resources
   ```

   Os nomes padrão da conta de serviço para o servidor do Livy e a sessão do Spark são `emr-containers-sa-livy` e `emr-containers-sa-spark-livy`. Para usar nomes personalizados, utilize os parâmetros `serviceAccounts.name` e `sparkServiceAccount.name`.

   ```
   --set serviceAccounts.name=my-service-account-for-livy
   --set sparkServiceAccount.name=my-service-account-for-spark
   ```

1. Verifique se você instalou o chart do Helm.

   ```
   helm list -n livy-ns -o yaml
   ```

   O comando `helm list` deve retornar as informações sobre o novo chart do Helm.

   ```
   app_version: 0.7.1-incubating
   chart: livy-emr-7.12.0
   name: livy-demo
   namespace: livy-ns
   revision: "1"
   status: deployed
   updated: 2024-02-08 22:39:53.539243 -0800 PST
   ```

1. Verifique se o Network Load Balancer está ativo.

   ```
   LIVY_NAMESPACE=<livy-ns>
   LIVY_APP_NAME=<livy-app-name>
   AWS_REGION=<AWS_REGION>
   
   # Get the NLB Endpoint URL
   NLB_ENDPOINT=$(kubectl --namespace $LIVY_NAMESPACE get svc -l "app.kubernetes.io/instance=$LIVY_APP_NAME,emr-containers.amazonaws.com/type=loadbalancer" -o jsonpath='{.items[0].status.loadBalancer.ingress[0].hostname}') 
   
   # Get all the load balancers in the account's region
   ELB_LIST=$(aws elbv2 describe-load-balancers --region $AWS_REGION)
   
   # Get the status of the NLB that matching the endpoint from the Kubernetes service
   NLB_STATUS=$(echo $ELB_LIST | grep -A 8 "\"DNSName\": \"$NLB_ENDPOINT\"" | awk '/Code/{print $2}/}/' | tr -d '"},\n')
   echo $NLB_STATUS
   ```

1. Agora, verifique se o grupo de destino no Network Load Balancer está íntegro.

   ```
   LIVY_NAMESPACE=<livy-ns>
   LIVY_APP_NAME=<livy-app-name>
   AWS_REGION=<AWS_REGION>
   
   # Get the NLB endpoint
   NLB_ENDPOINT=$(kubectl --namespace $LIVY_NAMESPACE get svc -l "app.kubernetes.io/instance=$LIVY_APP_NAME,emr-containers.amazonaws.com/type=loadbalancer" -o jsonpath='{.items[0].status.loadBalancer.ingress[0].hostname}') 
   
   # Get all the load balancers in the account's region
   ELB_LIST=$(aws elbv2 describe-load-balancers --region $AWS_REGION)
   
   # Get the NLB ARN from the NLB endpoint
   NLB_ARN=$(echo $ELB_LIST | grep -B 1 "\"DNSName\": \"$NLB_ENDPOINT\"" | awk '/"LoadBalancerArn":/,/"/'| awk '/:/{print $2}' | tr -d \",)
   
   # Get the target group from the NLB. Livy setup only deploys 1 target group
   TARGET_GROUP_ARN=$(aws elbv2 describe-target-groups --load-balancer-arn $NLB_ARN --region $AWS_REGION | awk '/"TargetGroupArn":/,/"/'| awk '/:/{print $2}' | tr -d \",)
   
   # Get health of target group
   aws elbv2 describe-target-health --target-group-arn $TARGET_GROUP_ARN
   ```

   Este é um exemplo de saída que mostra o status do grupo de destino:

   ```
   {
       "TargetHealthDescriptions": [
           {
               "Target": {
                   "Id": "<target IP>",
                   "Port": 8998,
                   "AvailabilityZone": "us-west-2d"
               },
               "HealthCheckPort": "8998",
               "TargetHealth": {
                   "State": "healthy"
               }
           }
       ]
   }
   ```

   Quando o status do NLB se tornar `active` e o grupo de destino `healthy`, você poderá continuar. Pode demorar alguns minutos.

1. Recupere o endpoint do Livy da instalação do Helm. Se o endpoint do Livy é seguro ou não, depende de você ter habilitado o SSL.

   ```
   LIVY_NAMESPACE=<livy-ns>
    LIVY_APP_NAME=livy-app-name
    LIVY_ENDPOINT=$(kubectl get svc -n livy-ns -l app.kubernetes.io/instance=livy-app-name,emr-containers.amazonaws.com/type=loadbalancer -o jsonpath='{.items[0].status.loadBalancer.ingress[0].hostname}' |  awk '{printf "%s:8998\n", $0}')
    echo "$LIVY_ENDPOINT"
   ```

1. Recuperação da conta de serviço do Spark na instalação do Helm

   ```
   SPARK_NAMESPACE=spark-ns
   LIVY_APP_NAME=<livy-app-name>
   SPARK_SERVICE_ACCOUNT=$(kubectl --namespace $SPARK_NAMESPACE get sa -l "app.kubernetes.io/instance=$LIVY_APP_NAME" -o jsonpath='{.items[0].metadata.name}')
   echo "$SPARK_SERVICE_ACCOUNT"
   ```

   Você deverá ver algo semelhante ao resultado a seguir:

   ```
   emr-containers-sa-spark-livy
   ```

1. Se você configurar `internalALB=true` para habilitar o acesso de fora da sua VPC, crie uma EC2 instância da Amazon e certifique-se de que o Network Load Balancer permita tráfego de rede proveniente da instância. EC2 Você deve fazer isso para que a instância tenha acesso ao endpoint do Livy. Para obter mais informações sobre como expor com segurança o endpoint fora da VPC, consulte [Setting up with a secure Apache Livy endpoint with TLS/SSL](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-secure-endpoint.html).

1. A instalação do Livy cria a conta de serviço `emr-containers-sa-spark` para executar as aplicações do Spark. Se seu aplicativo Spark usa AWS recursos como o S3 ou chama operações de AWS API ou CLI, você deve vincular uma função do IAM com as permissões necessárias à sua conta de serviço do Spark. Para obter mais informações, consulte [Setting up access permissions with IAM roles for service accounts (IRSA).](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-irsa.html)

O Apache Livy oferece suporte a configurações adicionais que você pode usar ao instalar o Livy. Para obter mais informações, consulte Propriedades de instalação do Apache Livy no Amazon EMR nas versões do EKS.

# Execução de uma aplicação do Spark com o Apache Livy para o Amazon EMR no EKS
<a name="job-runs-apache-livy-run-spark"></a>

Antes de executar uma aplicação do Spark com o Apache Livy, certifique-se de ter concluído as etapas em [Configuração do Apache Livy para o Amazon EMR no EKS](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html) e [Getting started with Apache Livy for Amazon EMR on EKS](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-install.html).

Você pode usar o Apache Livy para executar dois tipos de aplicações:
+ Sessões em lote: um tipo de workload do Livy para enviar trabalhos em lote do Spark.
+ Sessões interativas: um tipo de workload do Livy que fornece uma interface programática e visual para executar consultas do Spark.

**nota**  
Pods de drivers e de executores de sessões diferentes podem se comunicar entre si. Os namespaces não garantem nenhuma segurança entre os pods. O Kubernetes não aceita permissões seletivas em um subconjunto de pods dentro de um determinado namespace.

## Execução de sessões em lote
<a name="job-runs-apache-livy-run-spark-batch"></a>

Para enviar um trabalho em lote, use o comando a seguir.

```
curl -s -k -H 'Content-Type: application/json' -X POST \
      -d '{
            "name": "my-session",
            "file": "entryPoint_location (S3 or local)",
            "args": ["argument1", "argument2", ...],
            "conf": {
                "spark.kubernetes.namespace": "<spark-namespace>",
                "spark.kubernetes.container.image": "public.ecr.aws/emr-on-eks/spark/emr-7.12.0:latest",
                "spark.kubernetes.authenticate.driver.serviceAccountName": "<spark-service-account>"
            }
          }' <livy-endpoint>/batches
```

Para monitorar seu trabalho em lote, use o comando a seguir.

```
curl -s -k -H 'Content-Type: application/json' -X GET <livy-endpoint>/batches/my-session
```

## Execução de sessões interativas
<a name="job-runs-apache-livy-run-spark-interactive"></a>

Para executar sessões interativas com o Apache Livy, consulte as etapas a seguir.

1. Certifique-se de ter acesso a um notebook Jupyter auto-hospedado ou gerenciado, como um notebook SageMaker AI Jupyter. O caderno Jupyter deve ter o [sparkmagic](https://github.com/jupyter-incubator/sparkmagic/blob/master/README.md) instalado.

1. Crie um bucket para a configuração `spark.kubernetes.file.upload.path` do Spark. Certifique-se de que a conta de serviço do Spark tenha acesso de leitura e gravação ao bucket. Para obter mais detalhes sobre como configurar a conta de serviço do Spark, consulte Setting up access permissions with IAM roles for service accounts (IRSA)

1. Faça upload do sparkmagic no caderno Jupyter com o comando `%load_ext sparkmagic.magics`.

1. Execute o comando `%manage_spark` para configurar o endpoint do Livy com o caderno Jupyter. Selecione a guia **Adicionar endpoints**, escolha o tipo de autenticação configurado, adicione o endpoint do Livy ao caderno e escolha **Adicionar endpoint**.

1. Execute `%manage_spark` novamente para criar o contexto do Spark e vá para **Criar sessão**. Escolha o endpoint do Livy, especifique um nome de sessão exclusivo, escolha um idioma e adicione as propriedades a seguir.

   ```
   {
     "conf": {
       "spark.kubernetes.namespace": "livy-namespace",
       "spark.kubernetes.container.image": "public.ecr.aws/emr-on-eks/spark/emr-7.12.0:latest",
       "spark.kubernetes.authenticate.driver.serviceAccountName": "<spark-service-account>", 
       "spark.kubernetes.file.upload.path": "<URI_TO_S3_LOCATION_>"
     }
   }
   ```

1. Envie a aplicação e espere que ela crie o contexto do Spark.

1. Para monitorar o status da sessão interativa, execute o comando a seguir.

   ```
   curl -s -k -H 'Content-Type: application/json' -X GET livy-endpoint/sessions/my-interactive-session
   ```

## Monitoramento de aplicações do Spark
<a name="job-runs-apache-livy-run-ui"></a>

Para monitorar o progresso das aplicações do Spark com a interface de usuário do Livy, use o link `http://<livy-endpoint>/ui`.

# Desinstalação do Apache Livy com o Amazon EMR no EKS
<a name="job-runs-apache-livy-uninstall"></a>

Siga estas etapas para desinstalar o Apache Livy.

1. Exclua a configuração do Livy usando os nomes do namespace e o nome da aplicação. Neste exemplo, o nome da aplicação é `livy-demo` e o namespace é `livy-ns`.

   ```
   helm uninstall livy-demo -n livy-ns
   ```

1. Ao desinstalar, o Amazon EMR no EKS exclui o serviço Kubernetes no Livy, os balanceadores de carga e os AWS grupos-alvo que você criou durante a instalação. A exclusão de recursos pode levar alguns minutos. Certifique-se de que os recursos sejam excluídos antes de instalar o Livy no namespace novamente.

1. Exclua o namespace do Spark.

   ```
   kubectl delete namespace spark-ns
   ```

# Segurança para o Apache Livy com o Amazon EMR no EKS
<a name="job-runs-apache-livy-security"></a>

Consulte os tópicos a seguir para saber mais sobre como configurar a segurança do Apache Livy com o Amazon EMR no EKS. Essas opções incluem o uso da segurança da camada de transporte, o controle de acesso baseado em perfis, que é o acesso baseado no perfil de uma pessoa dentro de uma organização, e o uso de perfis do IAM, que fornecem acesso aos recursos de acordo com as permissões concedidas.

**Topics**
+ [Configuração de um endpoint do Apache Livy seguro com TLS/SSL](job-runs-apache-livy-secure-endpoint.md)
+ [Configuração das permissões de aplicações do Apache Livy e Spark com o controle de acesso por perfil (RBAC)](job-runs-apache-livy-rbac.md)
+ [Configuração de permissões de acesso com perfis do IAM para contas de serviço (IRSA)](job-runs-apache-livy-irsa.md)

# Configuração de um endpoint do Apache Livy seguro com TLS/SSL
<a name="job-runs-apache-livy-secure-endpoint"></a>

Consulte as seções a seguir para saber mais sobre como configurar o Apache Livy para Amazon EMR no EKS com criptografia end-to-end TLS e SSL.

## Configuração da criptografia TLS e SSL
<a name="job-runs-apache-livy-security-tls"></a>

Para configurar a criptografia SSL no endpoint do Apache Livy, siga estas etapas.
+ [Instale o driver CSI do Secrets Store e o AWS Secrets and Configuration Provider (ASCP)](https://docs.aws.amazon.com/secretsmanager/latest/userguide/integrating_csi_driver.html) — o driver CSI e o ASCP do Secrets Store armazenam com segurança os certificados e senhas JKS do Livy que o pod do servidor Livy precisa para habilitar o SSL. Você também pode instalar apenas o driver CSI do Secrets Store e usar qualquer outro provedor de segredos compatível.
+ [Crie um certificado do ACM](https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request-public.html): esse certificado é necessário para proteger a conexão entre o cliente e o endpoint do ALB.
+ Configure um certificado JKS, uma senha de chave e uma senha de armazenamento de chaves para AWS Secrets Manager — necessários para proteger a conexão entre o endpoint ALB e o servidor Livy.
+ Adicione permissões à conta de serviço Livy para recuperar segredos AWS Secrets Manager — o servidor Livy precisa dessas permissões para recuperar segredos do ASCP e adicionar as configurações Livy para proteger o servidor Livy. Para adicionar permissões do IAM a uma conta de serviço, consulte Setting up access permissions with IAM roles for service accounts (IRSA).

### Configurando um certificado JKS com uma chave e uma senha do keystore para AWS Secrets Manager
<a name="job-runs-apache-livy-jks-certificate"></a>

Siga estas etapas para configurar um certificado do JKS com uma chave e uma senha do keystore.

1. Gere um arquivo do keystore para o servidor do Livy.

   ```
   keytool -genkey -alias <host> -keyalg RSA -keysize 2048 –dname CN=<host>,OU=hw,O=hw,L=<your_location>,ST=<state>,C=<country> –keypass <keyPassword> -keystore <keystore_file> -storepass <storePassword> --validity 3650
   ```

1. Crie um certificado.

   ```
   keytool -export -alias <host> -keystore mykeystore.jks -rfc -file mycertificate.cert -storepass <storePassword>
   ```

1. Crie um arquivo da truststore.

   ```
   keytool -import -noprompt -alias <host>-file <cert_file> -keystore <truststore_file> -storepass <truststorePassword>
   ```

1. Salve o certificado JKS em AWS Secrets Manager. Substitua `livy-jks-secret` pelo segredo e `fileb://mykeystore.jks` pelo caminho para o certificado do JKS do keystore.

   ```
   aws secretsmanager create-secret \ 
   --name livy-jks-secret \
   --description "My Livy keystore JKS secret" \
   --secret-binary fileb://mykeystore.jks
   ```

1. Salve o a senha do keystore e da chave no Secrets Manager. Use seus próprios parâmetros.

   ```
   aws secretsmanager create-secret \
   --name livy-jks-secret \
   --description "My Livy key and keystore password secret" \
   --secret-string "{\"keyPassword\":\"<test-key-password>\",\"keyStorePassword\":\"<test-key-store-password>\"}"
   ```

1. Crie um namespace de servidor do Livy com o comando a seguir.

   ```
   kubectl create ns <livy-ns>
   ```

1. Crie o objeto `ServiceProviderClass` para o servidor do Livy que tem o certificado do JKS e as senhas.

   ```
   cat >livy-secret-provider-class.yaml << EOF
   apiVersion: secrets-store.csi.x-k8s.io/v1
   kind: SecretProviderClass
   metadata:
     name: aws-secrets
   spec:
     provider: aws
     parameters:
       objects: |
           - objectName: "livy-jks-secret"
             objectType: "secretsmanager"
           - objectName: "livy-passwords"
             objectType: "secretsmanager"
                        
   EOF
   kubectl apply -f livy-secret-provider-class.yaml -n <livy-ns>
   ```

## Conceitos básicos do Apache Livy habilitado por SSL
<a name="job-runs-apache-livy-ssl-enabled-getting-started"></a>

Depois de habilitar o SSL no servidor do Livy, você deve configurar a `serviceAccount` para ter acesso aos segredos de `keyStore` e `keyPasswords` no AWS Secrets Manager.

1. Crie o namespace do servidor do Livy.

   ```
   kubectl create namespace <livy-ns>
   ```

1. Configure a conta de serviço do Livy para ter acesso aos segredos no Secrets Manager. Para obter mais informações sobre como configurar o IRSA, consulte [Setting up IRSA while installing Apache Livy](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-irsa.html#job-runs-apache-livy-irsa).

   ```
   aws ecr get-login-password \--region region-id | helm registry login \
   --username AWS \
   --password-stdin ECR-registry-account.dkr.ecr.region-id.amazonaws.com
   ```

1. Instale o Livy. Para o parâmetro de versão do chart do Helm, use o rótulo de lançamento do Amazon EMR, como `7.1.0`. Você também deve substituir o ID da conta de registro e o ID da região do Amazon ECR pelos seus IDs. Você pode encontrar o `ECR-registry-account` valor correspondente para suas [contas Região da AWS de registro do Amazon ECR por região](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/docker-custom-images-tag.html#docker-custom-images-ECR).

   ```
   helm install <livy-app-name> \
     oci://895885662937.dkr.ecr.region-id.amazonaws.com/livy \
     --version 7.12.0 \
     --namespace livy-namespace-name \
     --set image=<ECR-registry-account.dkr.ecr>.<region>.amazonaws.com/livy/emr-7.12.0:latest \
     --set sparkNamespace=spark-namespace \
     --set ssl.enabled=true
     --set ssl.CertificateArn=livy-acm-certificate-arn
     --set ssl.secretProviderClassName=aws-secrets
     --set ssl.keyStoreObjectName=livy-jks-secret
     --set ssl.keyPasswordsObjectName=livy-passwords
     --create-namespace
   ```

1. Continue a partir da etapa 5 em [Installing Apache Livy on Amazon EMR on EKS](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html#job-runs-apache-livy-install).

# Configuração das permissões de aplicações do Apache Livy e Spark com o controle de acesso por perfil (RBAC)
<a name="job-runs-apache-livy-rbac"></a>

Para implantar o Livy, o Amazon EMR no EKS cria uma conta e perfil de serviço do servidor e uma conta e perfil de serviço do Spark. Esses perfis devem ter as permissões do RBAC necessárias para concluir a configuração e executar as aplicações do Spark.

**Permissões do RBAC para o perfil e a conta de serviço do servidor**

O Amazon EMR no EKS cria a conta e o perfil de serviço do servidor do Livy para gerenciar sessões do Livy para trabalhos do Spark e rotear o tráfego entre a entrada e outros recursos.

O nome padrão para esta conta de serviço é `emr-containers-sa-livy`. É necessário ter as permissões a seguir.

```
rules:
- apiGroups:
  - ""
  resources:
  - "namespaces"
  verbs:
  - "get"
- apiGroups:
  - ""
  resources:
  - "serviceaccounts"
    "services"
    "configmaps"
    "events"
    "pods"
    "pods/log"
  verbs:
  - "get"
    "list"
    "watch"
    "describe"
    "create"
    "edit"
    "delete"
    "deletecollection"
    "annotate"
    "patch"
    "label"
 - apiGroups:
   - ""
   resources:
   - "secrets"
   verbs:
   - "create"
     "patch"
     "delete"
     "watch"
 - apiGroups:
   - ""
   resources:
   - "persistentvolumeclaims"
   verbs:
   - "get"
     "list"
     "watch"
     "describe"
     "create"
     "edit"
     "delete"
     "annotate"
     "patch"
     "label"
```

**Permissões do RBAC para a conta e o perfil de serviço do Spark**

Um pod do driver do Spark precisa de uma conta de serviço do Kubernetes no mesmo namespace que o pod. Essa conta de serviço precisa de permissões para gerenciar os pods do executor e todos os recursos exigidos pelo pod do driver. A menos que a conta de serviço padrão no namespace tenha as permissões necessárias, o driver falhará e será encerrado. As permissões RBAC a seguir são necessárias.

```
rules:
- apiGroups:
  - ""
    "batch"
    "extensions"
    "apps"
  resources:
  - "configmaps"
    "serviceaccounts"
    "events"
    "pods"
    "pods/exec"
    "pods/log"
    "pods/portforward"
    "secrets"
    "services"
    "persistentvolumeclaims"
    "statefulsets"
  verbs:
  - "create"
    "delete"
    "get"
    "list"
    "patch"
    "update"
    "watch"
    "describe"
    "edit"
    "deletecollection"
    "patch"
    "label"
```

# Configuração de permissões de acesso com perfis do IAM para contas de serviço (IRSA)
<a name="job-runs-apache-livy-irsa"></a>

Por padrão, o driver e os executores do servidor Livy e do aplicativo Spark não têm acesso aos recursos. AWS A conta de serviço do servidor e a conta de serviço do Spark controlam o acesso aos AWS recursos do servidor Livy e dos pods do aplicativo Spark. Para conceder acesso, você precisa mapear as contas de serviço com uma função do IAM que tenha as AWS permissões necessárias.

Você pode configurar o mapeamento do IRSA antes de instalar o Apache Livy, durante a instalação ou depois de concluir a instalação.

## Configuração do IRSA durante a instalação do Apache Livy (para conta de serviço do servidor)
<a name="job-runs-apache-livy-irsa"></a>

**nota**  
Esse mapeamento é compatível somente com a conta de serviço do servidor.

1. Verifique se você concluiu a [configuração do Apache Livy para Amazon EMR no EKS](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html) e está no meio da [instalação do Apache Livy com o Amazon EMR no EKS](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-install.html). 

1. Crie um namespace do Kubernetes para o servidor do Livy. Neste exemplo, o nome do namespace é `livy-ns`.

1. Crie uma política do IAM que inclua as permissões Serviços da AWS para as quais você deseja que seus pods acessem. O exemplo a seguir cria uma política do IAM para obter recursos do Amazon S3 para o ponto de entrada do Spark.

   ```
   cat >my-policy.json <<EOF{
   "Version": "2012-10-17",		 	 	 
       "Statement": [
           {
   "Effect": "Allow",
               "Action": "s3:GetObject",
               "Resource": "arn:aws:s3:::my-spark-entrypoint-bucket"
           }
       ]
   }
   EOF
   
   aws iam create-policy --policy-name my-policy --policy-document file://my-policy.json
   ```

1. Use o comando a seguir para definir seu Conta da AWS ID como uma variável.

   ```
   account_id=$(aws sts get-caller-identity --query "Account" --output text)
   ```

1. Defina o provedor de identidade OpenID Connect (OIDC) do cluster como uma variável de ambiente.

   ```
   oidc_provider=$(aws eks describe-cluster --name my-cluster --region $AWS_REGION --query "cluster.identity.oidc.issuer" --output text | sed -e "s/^https:\/\///")
   ```

1. Defina variáveis para o namespace e o nome da conta de serviço. Use seus próprios valores.

   ```
   export namespace=default
   export service_account=my-service-account
   ```

1. Crie um arquivo de política de confiança com o comando a seguir. Se quiser conceder acesso ao perfil a todas as contas de serviço em um namespace, copie o comando a seguir e substitua `StringEquals` por `StringLike` e `$service_account` por `*`.

   ```
   cat >trust-relationship.json <<EOF
   {
     "Version": "2012-10-17",		 	 	 
     "Statement": [
       {
         "Effect": "Allow",
         "Principal": {
           "Federated": "arn:aws:iam::$account_id:oidc-provider/$oidc_provider"
         },
         "Action": "sts:AssumeRoleWithWebIdentity",
         "Condition": {
           "StringEquals": {
             "$oidc_provider:aud": "sts.amazonaws.com",
             "$oidc_provider:sub": "system:serviceaccount:$namespace:$service_account"
           }
         }
       }
     ]
   }
   EOF
   ```

1. Crie a função.

   ```
   aws iam create-role --role-name my-role --assume-role-policy-document file://trust-relationship.json --description "my-role-description"
   ```

1. Use o comando de instalação do Helm a seguir para configurar o `serviceAccount.executionRoleArn` para mapear o IRSA. Confira a seguir um exemplo do comando de instalação do Helm. Você pode encontrar o `ECR-registry-account` valor correspondente para suas [contas Região da AWS de registro do Amazon ECR por região](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/docker-custom-images-tag.html#docker-custom-images-ECR).

   ```
   helm install livy-demo \
     oci://895885662937.dkr.ecr.us-west-2.amazonaws.com/livy \
     --version 7.12.0 \
     --namespace livy-ns \
     --set image=ECR-registry-account.dkr.ecr.region-id.amazonaws.com/livy/emr-7.12.0:latest \
     --set sparkNamespace=spark-ns \
     --set serviceAccount.executionRoleArn=arn:aws:iam::123456789012:role/my-role
   ```

## Mapeamento do IRSA para uma conta de serviço do Spark
<a name="job-runs-apache-livy-irsa-spark"></a>

Antes de mapear o IRSA para uma conta de serviço do Spark, conclua os seguintes itens:
+ Verifique se você concluiu a [configuração do Apache Livy para Amazon EMR no EKS](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html) e está no meio da [instalação do Apache Livy com o Amazon EMR no EKS](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-install.html). 
+ Você deve ter um provedor OpenID Connect (OIDC) existente do IAM para o cluster. Para verificar se você já tem um provedor ou saber como criar um, consulte [Criar um provedor OIDC do IAM para o cluster](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html).
+ Certifique-se de ter instalado a versão 0.171.0 ou posterior da CLI do `eksctl` ou o AWS CloudShell. Para instalar ou atualizar o `eksctl`, consulte [Instalação](https://eksctl.io/installation/) na documentação do `eksctl`.

Siga estas etapas para mapear o IRSA à conta de serviço do Spark:

1. Use o comando a seguir para obter a conta de serviço do Spark.

   ```
   SPARK_NAMESPACE=<spark-ns>
   LIVY_APP_NAME=<livy-app-name>
   kubectl --namespace $SPARK_NAMESPACE describe sa -l "app.kubernetes.io/instance=$LIVY_APP_NAME" | awk '/^Name:/ {print $2}'
   ```

1. Defina variáveis para o namespace e o nome da conta de serviço.

   ```
   export namespace=default
   export service_account=my-service-account
   ```

1. Use o comando a seguir para criar um arquivo de política de confiança para o perfil do IAM. O exemplo a seguir dá permissão a todas as contas de serviço dentro do namespace para usar o perfil. Para fazer isso, substitua `StringEquals` por `StringLike` e `$service_account` por \$1.

   ```
   cat >trust-relationship.json <<EOF
   {
     "Version": "2012-10-17",		 	 	 
     "Statement": [
       {
         "Effect": "Allow",
         "Principal": {
           "Federated": "arn:aws:iam::$account_id:oidc-provider/$oidc_provider"
         },
         "Action": "sts:AssumeRoleWithWebIdentity",
         "Condition": {
           "StringEquals": {
             "$oidc_provider:aud": "sts.amazonaws.com",
             "$oidc_provider:sub": "system:serviceaccount:$namespace:$service_account"
           }
         }
       }
     ]
   }
   EOF
   ```

1. Crie a função.

   ```
   aws iam create-role --role-name my-role --assume-role-policy-document file://trust-relationship.json --description "my-role-description"
   ```

1. Mapeie o servidor ou a conta de serviço do Spark com o comando `eksctl` a seguir. Use seus próprios valores.

   ```
    eksctl create iamserviceaccount --name spark-sa \
    --namespace spark-namespace --cluster livy-eks-cluster \
    --attach-role-arn arn:aws:iam::0123456789012:role/my-role \
    --approve --override-existing-serviceaccounts
   ```

# Propriedades de instalação do Apache Livy em versões do Amazon EMR no EKS
<a name="job-runs-apache-livy-installation-properties"></a>

A instalação do Apache Livy permite que você selecione uma versão do chart do Helm no Livy. O chart do Helm oferece uma variedade de propriedades para personalizar sua experiência de instalação e configuração. Essas propriedades são compatíveis com o Amazon EMR no EKS nas versões 7.1.0 e superiores.

**Topics**
+ [Propriedades de instalação do Amazon EMR 7.1.0](#job-runs-apache-livy-installation-properties-710)

## Propriedades de instalação do Amazon EMR 7.1.0
<a name="job-runs-apache-livy-installation-properties-710"></a>

A tabela a seguir descreve todas as propriedades do Livy compatíveis. Ao instalar o Apache Livy, você pode escolher a versão do chart do Helm no Livy. Para definir uma propriedade durante a instalação, use o comando `--set <property>=<value>`.


| Propriedade | Description | Padrão | 
| --- | --- | --- | 
| image | O URI de lançamento do Amazon EMR do servidor do Livy. Essa configuração é necessária. | "" | 
| sparkNamespace | Namespace para executar sessões do Livy do Spark. Por exemplo, especifique "livy". Essa configuração é necessária. | "" | 
| nameOverride | Forneça um nome em vez de livy. O nome é definido como um rótulo para todos os recursos do Livy | "livy" | 
| fullnameOverride | Forneça um nome para usar em vez dos nomes completos dos recursos. | "" | 
| ssl.enabled | Habilita o end-to-end SSL do endpoint Livy para o servidor Livy. | FALSE | 
| ssl.certificateArn | Se o SSL estiver habilitado, esse será o ARN do certificado do ACM para o NLB criado pelo serviço. | "" | 
| ssl. secretProviderClassNome | Se o SSL estiver habilitado, esse é o nome da classe do provedor secreto para proteger o NLB na conexão do servidor do Livy com SSL. | "" | 
| ssl. keyStoreObjectNome | Se o SSL estiver habilitado, o nome do objeto do certificado do keystore na classe do provedor secreto. | "" | 
| ssl. keyPasswordsObjectNome | Se o SSL estiver habilitado, o nome do objeto do segredo que tem a senha do keystore e de chaves. | "" | 
| rbac.create | Se verdadeiro, cria recursos do RBAC. | FALSE | 
| serviceAccount.create | Se verdadeiro, cria uma conta de serviço do Livy. | TRUE | 
| serviceAccount.name | O nome da conta de serviço a ser usada no Livy. Se você não definir essa propriedade e criar uma conta de serviço, o Amazon EMR no EKS gerará automaticamente um nome usando a propriedade de substituição fullname. | "emr-containers-sa-livy" | 
| Conta de serviço. executionRoleArn | O ARN do perfil de execução da conta de serviço do Livy. | "" | 
| sparkServiceAccount.criar | SE verdadeiro, cria a conta de serviço do Spark no .Release.Namespace | TRUE | 
| sparkServiceAccount.name | O nome da conta de serviço que será usada no Spark. Se você não definir essa propriedade e criar uma conta de serviço do Spark, o Amazon EMR no EKS gerará automaticamente um nome com a propriedade fullnameOverride e o sufixo -spark-livy. | “emr-containers-sa-spark-lívio” | 
| service.name | O nome do serviço do Livy | "emr-containers-livy" | 
| service.annotations | Anotações do serviço do Livy | \$1\$1 | 
| loadbalancer.enabled | Se um balanceador de carga deve ser criado para o serviço Livy usado para expor o endpoint do Livy fora do cluster do Amazon EKS. | FALSE | 
| loadbalancer.internal | Se o endpoint do Livy deve ser configurado como interno à VPC ou externo. Definir essa propriedade para `FALSE` expõe o endpoint a fontes fora da VPC. Recomendamos proteger seu endpoint com TLS/SSL. Para obter mais informações, consulte [Setting up TLS and SSL encryption](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-security.html#job-runs-apache-livy-security-tls). | FALSE | 
| imagePullSecrets | A lista de nomes imagePullSecret a serem usados para extrair a imagem do Livy de repositórios privados. | [] | 
| recursos | As solicitações de recursos e os limites dos contêineres do Livy. | \$1\$1 | 
| nodeSelector | Os nós para os quais programar os pods do Livy. | \$1\$1 | 
| tolerations | Uma lista contendo as tolerâncias dos pods do Livy a serem definidas. | [] | 
| affinity | As regras de afinidade dos pods do Livy. | \$1\$1 | 
| persistence.enabled | Se verdadeiro, habilita a persistência dos diretórios de sessões. | FALSE | 
| persistence.subPath | O subcaminho da VPC a ser montado nos diretórios de sessões. | "" | 
| persistence.existingClaim | A VPC a ser usada em vez de criar uma nova. | \$1\$1 | 
| persistence.storageClass | A classe de armazenamento a ser usada. Para definir esse parâmetro, use o formato storageClassName: <storageClass>. Definir esse parâmetro para "-" desabilita o provisionamento dinâmico. Se você definir esse parâmetro como nulo ou não especificar nada, o Amazon EMR no EKS não definirá a e usará o storageClassName provisionador padrão. | "" | 
| persistence.accessMode | O modo de acesso da PVC. | ReadWriteOnce | 
| persistence.size | O tamanho da VPC. | 20 Gi | 
| persistence.annotations | Anotações adicionais para a VPC. | \$1\$1 | 
| env.\$1 | Ambientes adicionais a serem configurados no contêiner do Livy. Para obter mais informações, consulte [Inputting your own Livy and Spark configurations while installing Livy](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-troubleshooting.html). | \$1\$1 | 
| envFrom.\$1 | Ambientes adicionais a serem definidos para o Livy usando um mapa de configuração ou segredo do Kubernetes. | [] | 
| livyConf.\$1 | Entradas adicionais do livy.conf a serem definidas usando um mapa de configuração ou segredo montado do Kubernetes. | \$1\$1 | 
| sparkDefaultsConf.\$1 | Entradas adicionais de spark-defaults.conf a serem definidas usando um mapa de configuração ou segredo montado do Kubernetes. | \$1\$1 | 

# Solução de erros comuns de formato de variável de ambiente
<a name="job-runs-apache-livy-troubleshooting"></a>

Quando você insere as configurações do Livy e do Spark, há formatos de variáveis de ambiente que não são compatíveis e podem causar erros. O procedimento guia você por uma série de etapas que ajudam a garantir o uso de formatos corretos.

**Como inserir suas próprias configurações do Livy e do Spark ao instalar o Livy**

Você pode configurar qualquer variável de ambiente do Apache Livy ou do Apache Spark com a propriedade `env.*` do Helm. Siga as etapas abaixo para converter o exemplo de configuração `example.config.with-dash.withUppercase` em um formato de variável de ambiente compatível.

1. Substitua as letras maiúsculas por 1 e a forma minúscula da letra. Por exemplo, `example.config.with-dash.withUppercase` torna-se `example.config.with-dash.with1uppercase`.

1. Substitua traços (-) por 0. Por exemplo, `example.config.with-dash.with1uppercase` se torna `example.config.with0dash.with1uppercase`

1. Substitua pontos (.) por sublinhados (\$1). Por exemplo, `example.config.with0dash.with1uppercase` torna-se `example_config_with0dash_with1uppercase`.

1. Substitua todas as letras minúsculas por maiúsculas.

1. Adicione o prefixo `LIVY_` ao nome da variável.

1. Use a variável ao instalar o Livy por meio do gráfico de comando usando o formato --set env. *YOUR\$1VARIABLE\$1NAME*.valor= *yourvalue*

Por exemplo, para definir as configurações `livy.server.recovery.state-store = filesystem` e `spark.kubernetes.executor.podNamePrefix = my-prefix` do Livy e do Spark, use estas propriedades do Helm:

```
—set env.LIVY_LIVY_SERVER_RECOVERY_STATE0STORE.value=filesystem
—set env.LIVY_SPARK_KUBERNETES_EXECUTOR_POD0NAME0PREFIX.value=myprefix
```