Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Sicurezza per Apache Livy con Amazon EMR su EKS
<a name="job-runs-apache-livy-security"></a>

Consulta i seguenti argomenti per saperne di più sulla configurazione della sicurezza per Apache Livy con Amazon EMR su EKS. Queste opzioni includono l'utilizzo della sicurezza a livello di trasporto, il controllo degli accessi basato sui ruoli, ovvero l'accesso basato sul ruolo di una persona all'interno di un'organizzazione, e l'utilizzo dei ruoli IAM, che forniscono l'accesso alle risorse, in base alle autorizzazioni concesse.

**Topics**
+ [

# Configurazione di un endpoint Apache Livy sicuro con TLS/SSL
](job-runs-apache-livy-secure-endpoint.md)
+ [

# Configurazione delle autorizzazioni delle applicazioni Apache Livy e Spark con il controllo degli accessi basato sui ruoli (RBAC)
](job-runs-apache-livy-rbac.md)
+ [

# Configurazione delle autorizzazioni di accesso con i ruoli IAM per gli account di servizio (IRSA)
](job-runs-apache-livy-irsa.md)

# Configurazione di un endpoint Apache Livy sicuro con TLS/SSL
<a name="job-runs-apache-livy-secure-endpoint"></a>

Consulta le seguenti sezioni per saperne di più sulla configurazione di Apache Livy per Amazon EMR su EKS con crittografia end-to-end TLS e SSL.

## Configurazione della crittografia TLS e SSL
<a name="job-runs-apache-livy-security-tls"></a>

Per configurare la crittografia SSL sul tuo endpoint Apache Livy, segui questi passaggi.
+ [Installa il driver CSI Secrets Store e AWS Secrets and Configuration Provider (ASCP)](https://docs.aws.amazon.com/secretsmanager/latest/userguide/integrating_csi_driver.html): il driver CSI Secrets Store e ASCP archiviano in modo sicuro i certificati JKS e le password di Livy necessari al pod del server Livy per abilitare SSL. Puoi anche installare solo il driver CSI Secrets Store e utilizzare qualsiasi altro provider di segreti supportato.
+ [Crea un certificato ACM](https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request-public.html): questo certificato è necessario per proteggere la connessione tra il client e l'endpoint ALB.
+ Imposta un certificato JKS, una password di chiave e una password di archivio chiavi per, necessari per Gestione dei segreti AWS proteggere la connessione tra l'endpoint ALB e il server Livy.
+ Aggiungi le autorizzazioni all'account del servizio Livy da cui recuperare i segreti Gestione dei segreti AWS : il server Livy necessita di queste autorizzazioni per recuperare i segreti da ASCP e aggiungere le configurazioni Livy per proteggere il server Livy. Per aggiungere le autorizzazioni IAM a un account di servizio, consulta Configurazione delle autorizzazioni di accesso con i ruoli IAM per gli account di servizio (IRSA).

### Configurazione di un certificato JKS con una chiave e una password di archivio chiavi per Gestione dei segreti AWS
<a name="job-runs-apache-livy-jks-certificate"></a>

Segui questi passaggi per configurare un certificato JKS con una chiave e una password del keystore.

1. Genera un file keystore per il server 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. Crea un certificato.

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

1. Crea un file truststore.

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

1. Salva il certificato JKS in. Gestione dei segreti AWS Sostituiscilo `livy-jks-secret` con il tuo segreto e `fileb://mykeystore.jks` con il percorso del certificato JKS del keystore.

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

1. Salva il keystore e la password della chiave in Secrets Manager. Assicurati di utilizzare i tuoi parametri.

   ```
   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. Crea uno spazio dei nomi del server Livy con il seguente comando.

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

1. Crea l'`ServiceProviderClass`oggetto per il server Livy che ha il certificato JKS e le password.

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

## Guida introduttiva a Apache Livy abilitato per SSL
<a name="job-runs-apache-livy-ssl-enabled-getting-started"></a>

Dopo aver abilitato SSL sul tuo server Livy, devi `serviceAccount` configurarlo per avere accesso a and secrets su. `keyStore` `keyPasswords` Gestione dei segreti AWS

1. Crea lo spazio dei nomi del server Livy.

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

1. Configura l'account del servizio Livy per avere accesso ai segreti in Secrets Manager. Per ulteriori informazioni sulla configurazione di IRSA, vedere [Configurazione di IRSA durante l'installazione](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-irsa.html#job-runs-apache-livy-irsa) di Apache Livy.

   ```
   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. Installa Livy. Per il parametro Helm chart --version, usa l'etichetta di rilascio di Amazon EMR, ad esempio. `7.1.0` È inoltre necessario sostituire l'ID dell'account del registro Amazon ECR e l'ID regionale con i propri. IDs Puoi trovare il `ECR-registry-account` valore corrispondente per i tuoi [account del Regione AWS registro Amazon ECR per regione](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. Continua dal passaggio 5 dell'[Installazione di Apache Livy su Amazon EMR](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html#job-runs-apache-livy-install) su EKS.

# Configurazione delle autorizzazioni delle applicazioni Apache Livy e Spark con il controllo degli accessi basato sui ruoli (RBAC)
<a name="job-runs-apache-livy-rbac"></a>

Per distribuire Livy, Amazon EMR su EKS crea un account e un ruolo del servizio server e un account e un ruolo di servizio Spark. Questi ruoli devono disporre delle autorizzazioni RBAC necessarie per completare la configurazione ed eseguire le applicazioni Spark.

**Autorizzazioni RBAC per l'account e il ruolo del servizio server**

Amazon EMR su EKS crea l'account e il ruolo del servizio server Livy per gestire le sessioni Livy per i job Spark e il routing del traffico da e verso l'ingresso e altre risorse.

Il nome predefinito per questo account di servizio è `emr-containers-sa-livy`. Deve disporre delle seguenti autorizzazioni.

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

**Autorizzazioni RBAC per l'account e il ruolo del servizio Spark**

Un pod del driver Spark necessita di un account di servizio Kubernetes nello stesso spazio dei nomi del pod. Questo account di servizio necessita delle autorizzazioni per gestire gli executor pod e tutte le risorse richieste dal driver pod. A meno che l'account di servizio predefinito nel namespace non disponga delle autorizzazioni richieste, il driver si guasta e si chiude. Sono richieste le seguenti autorizzazioni RBAC.

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

# Configurazione delle autorizzazioni di accesso con i ruoli IAM per gli account di servizio (IRSA)
<a name="job-runs-apache-livy-irsa"></a>

Per impostazione predefinita, il server Livy e i driver e gli esecutori dell'applicazione Spark non hanno accesso alle risorse. AWS L'account del servizio server e l'account del servizio spark controllano l'accesso alle AWS risorse per il server Livy e i pod dell'applicazione Spark. Per concedere l'accesso, devi mappare gli account di servizio con un ruolo IAM dotato delle autorizzazioni necessarie. AWS 

È possibile configurare la mappatura IRSA prima di installare Apache Livy, durante l'installazione o dopo aver completato l'installazione.

## Configurazione di IRSA durante l'installazione di Apache Livy (per l'account del servizio server)
<a name="job-runs-apache-livy-irsa"></a>

**Nota**  
Questa mappatura è supportata solo per l'account del servizio server.

1. Assicurati di aver completato la [configurazione di Apache Livy per Amazon EMR su EKS](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html) e che sia in corso l'[installazione di Apache Livy con Amazon](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-install.html) EMR su EKS. 

1. Crea uno spazio dei nomi Kubernetes per il server Livy. In questo esempio, il nome dello spazio dei nomi è. `livy-ns`

1. Crea una policy IAM che includa le autorizzazioni Servizi AWS per le quali desideri che i tuoi pod accedano. L'esempio seguente crea una policy IAM per ottenere risorse Amazon S3 per il punto di ingresso 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. Usa il comando seguente per impostare il tuo Account AWS ID su una variabile.

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

1. Imposta il provider di identità OpenID Connect (OIDC) del cluster su una variabile di 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. Impostare le variabili per il namespace e il nome dell’account del servizio. Assicurati di utilizzare i tuoi valori.

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

1. Create un file di criteri di fiducia con il seguente comando. Se desideri concedere l'accesso al ruolo a tutti gli account di servizio all'interno di un namespace, copia il comando seguente e sostituiscilo con e `StringEquals` sostituiscilo con`StringLike`. `$service_account` `*`

   ```
   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. Crea il ruolo.

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

1. Utilizzate il seguente comando Helm install per impostare l'`serviceAccount.executionRoleArn`IRSA per mappare. Di seguito è riportato un esempio del comando Helm install. Puoi trovare il `ECR-registry-account` valore corrispondente per i tuoi [account del Regione AWS registro Amazon ECR per regione](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
   ```

## Mappatura di IRSA su un account di servizio Spark
<a name="job-runs-apache-livy-irsa-spark"></a>

Prima di mappare IRSA a un account di servizio Spark, assicurati di aver completato i seguenti elementi:
+ Assicurati di aver completato la [configurazione di Apache Livy per Amazon EMR su EKS](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html) e che sia in corso l'[installazione di Apache Livy con Amazon](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-install.html) EMR su EKS. 
+ È necessario disporre di un provider IAM OpenID Connect (OIDC) esistente per il cluster. Per vedere se ne hai già uno o come crearne uno, consulta [Creare un provider IAM OIDC](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html) per il tuo cluster.
+ Assicurati di aver installato la versione 0.171.0 o successiva della `eksctl` CLI installata o. AWS CloudShell Per installare o aggiornare`eksctl`, consulta [Installazione della documentazione](https://eksctl.io/installation/). `eksctl`

Segui questi passaggi per mappare IRSA al tuo account di servizio Spark:

1. Usa il seguente comando per ottenere l'account del servizio 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. Imposta le variabili per il namespace e il nome dell'account del servizio.

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

1. Utilizza il comando seguente per creare un file di policy di fiducia per il ruolo IAM. L'esempio seguente autorizza tutti gli account di servizio all'interno del namespace a utilizzare il ruolo. A tale scopo, sostituisci `StringEquals` con `StringLike` e sostituisci `$service_account` con \$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. Crea il ruolo.

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

1. Mappa l'account del server o del servizio Spark con il seguente `eksctl` comando. Assicurati di usare i tuoi valori.

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