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

# Guida introduttiva ad Apache Livy su Amazon EMR su EKS
<a name="job-runs-apache-livy-install"></a>

Completa i seguenti passaggi per installare Apache Livy. Includono la configurazione del gestore di pacchetti, la creazione di uno spazio dei nomi per l'esecuzione dei carichi di lavoro Spark, l'installazione di Livy, l'impostazione del bilanciamento del carico e i passaggi di verifica. Devi completare questi passaggi per eseguire un processo in batch con Spark.

1. Se non l'hai già fatto, configura [Apache Livy per Amazon EMR](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html) su EKS.

1. Autentica il client Helm nel registro Amazon ECR. 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).

   ```
   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. La configurazione di Livy crea un account di servizio per il server Livy e un altro account per l'applicazione Spark. Per configurare IRSA per gli account di servizio, consulta [Configurazione delle autorizzazioni di accesso con i ruoli IAM per gli account di servizio](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-irsa.html) (IRSA). 

1. Crea uno spazio dei nomi per eseguire i carichi di lavoro Spark.

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

1. Usa il seguente comando per installare Livy.

   Questo endpoint Livy è disponibile solo internamente per il VPC nel cluster EKS. Per abilitare l'accesso oltre il VPC, imposta il comando `—-set loadbalancer.internal=false` di installazione Helm.
**Nota**  
Per impostazione predefinita, SSL non è abilitato all'interno di questo endpoint Livy e l'endpoint è visibile solo all'interno del VPC del cluster EKS. Se imposti `loadbalancer.internal=false` and`ssl.enabled=false`, esponi un endpoint non sicuro all'esterno del tuo VPC. Per configurare un endpoint Livy sicuro, vedi [Configurazione](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-secure-endpoint.html) di un endpoint Apache Livy sicuro con TLS/SSL. 

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

   Vedrai il seguente output.

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

   I nomi degli account di servizio predefiniti per il server Livy e la sessione Spark sono e. `emr-containers-sa-livy` `emr-containers-sa-spark-livy` Per utilizzare nomi personalizzati, usa i parametri `serviceAccounts.name` and`sparkServiceAccount.name`.

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

1. Verifica di aver installato il grafico Helm.

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

   Il `helm list` comando dovrebbe restituire informazioni sul nuovo grafico 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. Verificare che il Network Load Balancer sia attivo.

   ```
   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. Ora verifica che il gruppo target nel Network Load Balancer sia sano.

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

   Di seguito è riportato un esempio di output che mostra lo stato del gruppo target:

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

   Una volta raggiunto lo status del vostro NLB `active` e del vostro gruppo target`healthy`, potete continuare. Questo processo può richiedere alcuni minuti.

1. Recupera l'endpoint Livy dall'installazione di Helm. Il fatto che il tuo endpoint Livy sia sicuro o meno dipende dal fatto che tu abbia abilitato 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 l'account del servizio Spark dall'installazione di 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"
   ```

   L'output visualizzato è simile al seguente:

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

1. Se imposti di `internalALB=true` abilitare l'accesso dall'esterno del tuo VPC, crea un' EC2 istanza Amazon e assicurati che Network Load Balancer consenta il traffico di rete proveniente dall'istanza. EC2 Devi farlo affinché l'istanza abbia accesso al tuo endpoint Livy. Per ulteriori informazioni sull'esposizione sicura dell'endpoint all'esterno del VPC, consulta [Configurazione con un endpoint Apache Livy sicuro con TLS/SSL](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-secure-endpoint.html).

1. L'installazione di Livy crea l'account di servizio per eseguire le applicazioni Spark. `emr-containers-sa-spark` Se la tua applicazione Spark utilizza AWS risorse come S3 o richiama operazioni AWS API o CLI, devi collegare un ruolo IAM con le autorizzazioni necessarie al tuo account del servizio spark. Per ulteriori informazioni, consulta [Configurazione delle autorizzazioni di accesso con i ruoli IAM per](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-irsa.html) gli account di servizio (IRSA).

Apache Livy supporta configurazioni aggiuntive che è possibile utilizzare durante l'installazione di Livy. Per ulteriori informazioni, consulta Proprietà di installazione per Apache Livy su Amazon EMR sulle versioni EKS.