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

# 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
   ```