Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Utilisation d'Apache Livy avec Amazon EMR sur EKS
<a name="job-runs-apache-livy"></a>

Avec les versions 7.1.0 et supérieures d'Amazon EMR, vous pouvez utiliser Apache Livy pour soumettre des tâches sur Amazon EMR sur EKS. À l'aide d'Apache Livy, vous pouvez configurer votre propre point de terminaison REST Apache Livy et l'utiliser pour déployer et gérer des applications Spark sur vos clusters Amazon EKS. Après avoir installé Livy dans votre cluster Amazon EKS, vous pouvez utiliser le point de terminaison Livy pour envoyer des applications Spark à votre serveur Livy. Le serveur gère le cycle de vie des applications Spark.

**Note**  
Amazon EMR calcule les tarifs sur Amazon EKS en fonction du vCPU et de la consommation de mémoire. Ce calcul s'applique aux modules pilote et exécuteur. Ce calcul commence à partir du moment où vous téléchargez l'image de votre application Amazon EMR jusqu'à ce que le module Amazon EKS se termine et est arrondi à la seconde près.

**Topics**
+ [Configuration d'Apache Livy pour Amazon EMR sur EKS](job-runs-apache-livy-setup.md)
+ [Commencer à utiliser Apache Livy sur Amazon EMR sur EKS](job-runs-apache-livy-install.md)
+ [Exécution d'une application Spark avec Apache Livy pour Amazon EMR sur EKS](job-runs-apache-livy-run-spark.md)
+ [Désinstaller Apache Livy avec Amazon EMR sur EKS](job-runs-apache-livy-uninstall.md)
+ [Sécurité pour Apache Livy avec Amazon EMR sur EKS](job-runs-apache-livy-security.md)
+ [Propriétés d'installation d'Apache Livy sur Amazon EMR sur les versions EKS](job-runs-apache-livy-installation-properties.md)
+ [Résoudre les erreurs de format courantes liées aux variables d'environnement](job-runs-apache-livy-troubleshooting.md)

# Configuration d'Apache Livy pour Amazon EMR sur EKS
<a name="job-runs-apache-livy-setup"></a>

Avant de pouvoir installer Apache Livy sur votre cluster Amazon EKS, vous devez installer et configurer un ensemble d'outils prérequis. Il s'agit notamment de l' AWS CLI outil de ligne de commande fondamental pour utiliser les AWS ressources, des outils de ligne de commande pour travailler avec Amazon EKS et d'un contrôleur utilisé dans ce cas d'utilisation pour mettre votre application de cluster à disposition sur Internet et pour acheminer le trafic réseau.
+ **[Installation ou mise à jour vers la dernière version du AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)** — Si vous avez déjà installé le AWS CLI, vérifiez que vous disposez de la dernière version.
+ **[Configurer kubectl et eksctl — eksctl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html)** est un outil de ligne de commande que vous utilisez pour communiquer avec Amazon EKS.
+ **[Installer Helm](https://docs.aws.amazon.com/eks/latest/userguide/helm.html)** – Le gestionnaire de packages Helm pour Kubernetes vous aide à installer et à gérer des applications sur votre cluster Kubernetes. 
+ **[Commencez avec Amazon EKS — eksctl](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html)** — Suivez les étapes pour créer un nouveau cluster Kubernetes avec des nœuds dans Amazon EKS.
+ **[Sélectionnez une étiquette de version Amazon EMR](docker-custom-images-tag.md)** : Apache Livy est compatible avec les versions 7.1.0 et supérieures d'Amazon EMR.
+ **[Installez le contrôleur ALB : le contrôleur](https://docs.aws.amazon.com/eks/latest/userguide/aws-load-balancer-controller.html)** ALB gère AWS Elastic Load Balancing pour les clusters Kubernetes. Il crée un AWS Network Load Balancer (NLB) lorsque vous créez une entrée Kubernetes lors de la configuration d'Apache Livy.

# Commencer à utiliser Apache Livy sur Amazon EMR sur EKS
<a name="job-runs-apache-livy-install"></a>

Procédez comme suit pour installer Apache Livy. Elles incluent la configuration du gestionnaire de packages, la création d'un espace de noms pour exécuter les charges de travail Spark, l'installation de Livy, la configuration de l'équilibrage de charge et les étapes de vérification. Vous devez suivre ces étapes pour exécuter un traitement par lots avec Spark.

1. Si ce n'est pas déjà fait, configurez [Apache Livy pour Amazon EMR sur](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html) EKS.

1. Authentifiez votre client Helm dans le registre Amazon ECR. Vous pouvez trouver la `ECR-registry-account` valeur correspondante pour vos [comptes Région AWS de registre Amazon ECR par région.](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 configuration de Livy crée un compte de service pour le serveur Livy et un autre compte pour l'application Spark. Pour configurer l'IRSA pour les comptes de service, consultez la section [Configuration des autorisations d'accès avec les rôles IAM pour les comptes de service (IRSA](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-irsa.html)). 

1. Créez un espace de noms pour exécuter vos charges de travail Spark.

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

1. Utilisez la commande suivante pour installer Livy.

   Ce point de terminaison Livy est uniquement disponible en interne pour le VPC dans le cluster EKS. Pour activer l'accès au-delà du VPC, définissez `—-set loadbalancer.internal=false` votre commande d'installation Helm.
**Note**  
Par défaut, le protocole SSL n'est pas activé dans ce point de terminaison Livy et le point de terminaison n'est visible que dans le VPC du cluster EKS. Si vous définissez `loadbalancer.internal=false` et`ssl.enabled=false`, vous exposez un point de terminaison non sécurisé à l'extérieur de votre VPC. Pour configurer un point de terminaison Livy sécurisé, voir [Configuration d'un point de terminaison Apache Livy sécurisé avec 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
   ```

   Le résultat suivant doit s'afficher.

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

   Les noms de compte de service par défaut pour le serveur Livy et la session Spark sont `emr-containers-sa-livy` et`emr-containers-sa-spark-livy`. Pour utiliser des noms personnalisés, utilisez les `sparkServiceAccount.name` paramètres `serviceAccounts.name` et.

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

1. Vérifiez que vous avez installé le graphique Helm.

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

   La `helm list` commande doit renvoyer des informations sur votre nouveau graphique 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. Vérifiez que le Network Load Balancer est actif.

   ```
   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. Vérifiez maintenant que le groupe cible du Network Load Balancer est sain.

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

   Voici un exemple de sortie qui montre l'état du groupe cible :

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

   Une fois que le statut de votre NLB sera atteint `active` et que votre groupe cible l'est`healthy`, vous pouvez continuer. Cette opération peut durer quelques minutes.

1. Récupérez le point de terminaison Livy depuis l'installation de Helm. La sécurité de votre point de terminaison Livy dépend de l'activation ou non du protocole 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. Récupérez le compte de service Spark depuis l'installation de 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"
   ```

   Le résultat doit ressembler à celui-ci :

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

1. Si vous avez configuré `internalALB=true` pour activer l'accès depuis l'extérieur de votre VPC, créez une EC2 instance Amazon et assurez-vous que le Network Load Balancer autorise le trafic réseau provenant de l'instance. EC2 Vous devez le faire pour que l'instance ait accès à votre point de terminaison Livy. Pour plus d'informations sur l'exposition sécurisée de votre point de terminaison en dehors de votre VPC, consultez [Configuration avec un point de terminaison Apache Livy sécurisé avec](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-secure-endpoint.html) TLS/SSL.

1. L'installation de Livy crée le compte de service `emr-containers-sa-spark` pour exécuter les applications Spark. Si votre application Spark utilise des AWS ressources telles que S3 ou appelle des opérations d' AWS API ou de CLI, vous devez associer un rôle IAM doté des autorisations nécessaires à votre compte de service Spark. Pour plus d'informations, voir [Configuration des autorisations d'accès avec les rôles IAM pour les comptes de service (IRSA](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-irsa.html)).

Apache Livy prend en charge des configurations supplémentaires que vous pouvez utiliser lors de l'installation de Livy. Pour plus d'informations, consultez la section Propriétés d'installation d'Apache Livy sur Amazon EMR sur les versions EKS.

# Exécution d'une application Spark avec Apache Livy pour Amazon EMR sur EKS
<a name="job-runs-apache-livy-run-spark"></a>

Avant de pouvoir exécuter une application Spark avec Apache Livy, assurez-vous d'avoir suivi les étapes décrites dans [Configuration d'Apache Livy pour Amazon EMR sur EKS](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html) et [Démarrage avec Apache Livy pour Amazon](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-install.html) EMR sur EKS.

Vous pouvez utiliser Apache Livy pour exécuter deux types d'applications :
+ Sessions par lots : type de charge de travail Livy permettant de soumettre des tâches par lots Spark.
+ Sessions interactives : type de charge de travail Livy qui fournit une interface programmatique et visuelle pour exécuter des requêtes Spark.

**Note**  
Les pods pilote et exécuteur issus de différentes sessions peuvent communiquer entre eux. Les espaces de noms ne garantissent aucune sécurité entre les pods. Kubernetes n'autorise pas d'autorisations sélectives sur un sous-ensemble de pods au sein d'un espace de noms donné.

## Exécution de sessions par lots
<a name="job-runs-apache-livy-run-spark-batch"></a>

Pour soumettre un traitement par lots, utilisez la commande suivante.

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

Pour surveiller votre traitement par lots, utilisez la commande suivante.

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

## Organisation de sessions interactives
<a name="job-runs-apache-livy-run-spark-interactive"></a>

Pour exécuter des sessions interactives avec Apache Livy, suivez les étapes ci-dessous.

1. Assurez-vous d'avoir accès à un bloc-notes Jupyter auto-hébergé ou géré, tel qu'un bloc-notes Jupyter SageMaker AI. [Sparkmagic](https://github.com/jupyter-incubator/sparkmagic/blob/master/README.md) doit être installé sur votre bloc-notes Jupyter.

1. Créez un bucket pour la configuration de Spark`spark.kubernetes.file.upload.path`. Assurez-vous que le compte de service Spark dispose d'un accès en lecture et en écriture au bucket. Pour plus de détails sur la configuration de votre compte de service Spark, consultez Configuration des autorisations d'accès avec les rôles IAM pour les comptes de service (IRSA)

1. Chargez sparkmagic dans le bloc-notes Jupyter à l'aide de la commande. `%load_ext sparkmagic.magics`

1. Exécutez la commande `%manage_spark` pour configurer votre point de terminaison Livy avec le bloc-notes Jupyter. **Choisissez l'onglet **Ajouter des points de terminaison**, choisissez le type d'authentification configuré, ajoutez le point de terminaison Livy au bloc-notes, puis choisissez Ajouter un point de terminaison.**

1. Exécutez à `%manage_spark` nouveau pour créer le contexte Spark, puis accédez à la **session Create**. Choisissez le point de terminaison Livy, spécifiez un nom de session unique, choisissez une langue, puis ajoutez les propriétés suivantes.

   ```
   {
     "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. Soumettez l'application et attendez qu'elle crée le contexte Spark.

1. Pour contrôler l'état de la session interactive, exécutez la commande suivante.

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

## Surveillance des applications Spark
<a name="job-runs-apache-livy-run-ui"></a>

Pour suivre la progression de vos applications Spark avec l'interface utilisateur Livy, utilisez le lien`http://<livy-endpoint>/ui`.

# Désinstaller Apache Livy avec Amazon EMR sur EKS
<a name="job-runs-apache-livy-uninstall"></a>

Pour désinstaller Apache Livy, procédez comme suit.

1. Supprimez la configuration de Livy en utilisant les noms de votre espace de noms et le nom de votre application. Dans cet exemple, le nom de l'application est `livy-demo` et l'espace de noms est`livy-ns`.

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

1. Lors de la désinstallation, Amazon EMR on EKS supprime le service Kubernetes dans Livy, les équilibreurs de charge et AWS les groupes cibles que vous avez créés lors de l'installation. La suppression de ressources peut prendre quelques minutes. Assurez-vous que les ressources sont supprimées avant de réinstaller Livy sur l'espace de noms.

1. Supprimez l'espace de noms Spark.

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

# Sécurité pour Apache Livy avec Amazon EMR sur EKS
<a name="job-runs-apache-livy-security"></a>

Consultez les rubriques suivantes pour en savoir plus sur la configuration de la sécurité pour Apache Livy avec Amazon EMR sur EKS. Ces options incluent l'utilisation de la sécurité de la couche de transport, le contrôle d'accès basé sur les rôles, c'est-à-dire l'accès basé sur le rôle d'une personne au sein d'une organisation, et l'utilisation des rôles IAM, qui fournissent un accès aux ressources, en fonction des autorisations accordées.

**Topics**
+ [Configuration d'un point de terminaison Apache Livy sécurisé avec TLS/SSL](job-runs-apache-livy-secure-endpoint.md)
+ [Configuration des autorisations des applications Apache Livy et Spark avec le contrôle d'accès basé sur les rôles (RBAC)](job-runs-apache-livy-rbac.md)
+ [Configuration des autorisations d'accès avec des rôles IAM pour les comptes de service (IRSA)](job-runs-apache-livy-irsa.md)

# Configuration d'un point de terminaison Apache Livy sécurisé avec TLS/SSL
<a name="job-runs-apache-livy-secure-endpoint"></a>

Consultez les sections suivantes pour en savoir plus sur la configuration d'Apache Livy pour Amazon EMR sur EKS end-to-end avec le chiffrement TLS et SSL.

## Configuration du chiffrement TLS et SSL
<a name="job-runs-apache-livy-security-tls"></a>

Pour configurer le chiffrement SSL sur votre point de terminaison Apache Livy, procédez comme suit.
+ [Installez le pilote CSI Secrets Store et le fournisseur de AWS secrets et de configuration (ASCP) : le pilote CSI et l'ASCP](https://docs.aws.amazon.com/secretsmanager/latest/userguide/integrating_csi_driver.html) de Secrets Store stockent en toute sécurité les certificats JKS et les mots de passe de Livy dont le pod de serveur Livy a besoin pour activer le protocole SSL. Vous pouvez également installer uniquement le pilote CSI Secrets Store et utiliser n'importe quel autre fournisseur de secrets compatible.
+ [Créez un certificat ACM : ce certificat](https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request-public.html) est nécessaire pour sécuriser la connexion entre le client et le point de terminaison ALB.
+ Configurez un certificat JKS, un mot de passe clé et un mot de passe de banque de clés pour AWS Secrets Manager  : nécessaire pour sécuriser la connexion entre le point de terminaison ALB et le serveur Livy.
+ Ajoutez des autorisations au compte de service Livy pour récupérer les secrets AWS Secrets Manager  : le serveur Livy a besoin de ces autorisations pour récupérer les secrets depuis ASCP et ajouter les configurations Livy pour sécuriser le serveur Livy. Pour ajouter des autorisations IAM à un compte de service, voir Configuration des autorisations d'accès avec des rôles IAM pour les comptes de service (IRSA).

### Configuration d'un certificat JKS avec une clé et un mot de passe de keystore pour AWS Secrets Manager
<a name="job-runs-apache-livy-jks-certificate"></a>

Procédez comme suit pour configurer un certificat JKS avec une clé et un mot de passe pour le keystore.

1. Générez un fichier keystore pour le serveur 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. Créez un certificat.

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

1. Créez un fichier Truststore.

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

1. Enregistrez le certificat JKS dans. AWS Secrets Manager`livy-jks-secret`Remplacez-le par votre code secret et `fileb://mykeystore.jks` par le chemin d'accès à votre certificat JKS de keystore.

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

1. Enregistrez le keystore et le mot de passe clé dans Secrets Manager. Assurez-vous d'utiliser vos propres paramètres.

   ```
   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. Créez un espace de noms de serveur Livy à l'aide de la commande suivante.

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

1. Créez l'`ServiceProviderClass`objet pour le serveur Livy qui possède le certificat JKS et les mots de passe.

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

## Commencer à utiliser Apache Livy compatible SSL
<a name="job-runs-apache-livy-ssl-enabled-getting-started"></a>

Après avoir activé le SSL sur votre serveur Livy, vous devez configurer le `serviceAccount` pour avoir accès aux `keyPasswords` secrets `keyStore` et. AWS Secrets Manager

1. Créez l'espace de noms du serveur Livy.

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

1. Configurez le compte de service Livy pour avoir accès aux secrets dans Secrets Manager. Pour plus d'informations sur la configuration de l'IRSA, voir [Configuration de l'IRSA lors de l'installation d'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. Installez Livy. Pour le paramètre Helm chart --version, utilisez votre étiquette de version Amazon EMR, telle que. `7.1.0` Vous devez également remplacer l'ID de compte de registre Amazon ECR et l'ID de région par les vôtres. IDs Vous pouvez trouver la `ECR-registry-account` valeur correspondante pour vos [comptes Région AWS de registre Amazon ECR par région.](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. Continuez à partir de l'étape 5 de l'[installation d'Apache Livy sur Amazon EMR](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html#job-runs-apache-livy-install) sur EKS.

# Configuration des autorisations des applications Apache Livy et Spark avec le contrôle d'accès basé sur les rôles (RBAC)
<a name="job-runs-apache-livy-rbac"></a>

Pour déployer Livy, Amazon EMR on EKS crée un compte et un rôle de service de serveur, ainsi qu'un compte et un rôle de service Spark. Ces rôles doivent disposer des autorisations RBAC nécessaires pour terminer la configuration et exécuter les applications Spark.

**Autorisations RBAC pour le compte de service et le rôle du serveur**

Amazon EMR on EKS crée le compte de service et le rôle du serveur Livy pour gérer les sessions Livy pour les tâches Spark et acheminer le trafic vers et depuis l'entrée et d'autres ressources.

Le nom par défaut de ce compte de service est `emr-containers-sa-livy`. Il doit disposer des autorisations suivantes.

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

**Autorisations RBAC pour le compte et le rôle du service Spark**

Le pod du pilote Spark a besoin d'un compte de service Kubernetes dans le même espace de noms que le pod. Ce compte de service a besoin d'autorisations pour gérer les modules d'exécution et toutes les ressources requises par le module de pilotes. À moins que le compte de service par défaut de l'espace de noms ne dispose des autorisations requises, le pilote échoue et se ferme. Les autorisations RBAC suivantes sont requises.

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

# Configuration des autorisations d'accès avec des rôles IAM pour les comptes de service (IRSA)
<a name="job-runs-apache-livy-irsa"></a>

Par défaut, le serveur Livy et le pilote et les exécuteurs de l'application Spark n'ont pas accès aux AWS ressources. Le compte de service du serveur et le compte de service Spark contrôlent l'accès aux AWS ressources pour le serveur Livy et les pods de l'application Spark. Pour accorder l'accès, vous devez associer les comptes de service à un rôle IAM disposant des AWS autorisations nécessaires.

Vous pouvez configurer le mappage IRSA avant d'installer Apache Livy, pendant l'installation ou après l'avoir terminée.

## Configuration de l'IRSA lors de l'installation d'Apache Livy (pour le compte de service du serveur)
<a name="job-runs-apache-livy-irsa"></a>

**Note**  
Ce mappage n'est pris en charge que pour le compte de service du serveur.

1. Assurez-vous que vous avez terminé de [configurer Apache Livy pour Amazon EMR sur](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html) EKS et que vous êtes en train [d'installer Apache Livy avec Amazon EMR](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-install.html) sur EKS. 

1. Créez un espace de noms Kubernetes pour le serveur Livy. Dans cet exemple, le nom de l'espace de noms est`livy-ns`.

1. Créez une politique IAM qui inclut les Services AWS autorisations auxquelles vous souhaitez que vos pods accèdent. L'exemple suivant crée une politique IAM permettant d'obtenir des ressources Amazon S3 pour le point d'entrée 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. Utilisez la commande suivante pour attribuer une variable à votre Compte AWS identifiant.

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

1. Définissez le fournisseur d'identité OpenID Connect (OIDC) de votre cluster sur une variable d'environnement.

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

1. Définissez des variables pour l'espace de noms et le nom du compte de service. Veillez à utiliser vos propres valeurs.

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

1. Créez un fichier de politique de confiance à l'aide de la commande suivante. Si vous souhaitez accorder l'accès au rôle à tous les comptes de service d'un espace de noms, copiez la commande suivante, remplacez `StringEquals` par `StringLike` et remplacez `$service_account` par`*`.

   ```
   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. Créez le rôle.

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

1. Utilisez la commande d'installation Helm suivante pour configurer IRSA `serviceAccount.executionRoleArn` pour mapper l'IRSA. Voici un exemple de commande d'installation de Helm. Vous pouvez trouver la `ECR-registry-account` valeur correspondante pour vos [comptes Région AWS de registre Amazon ECR par région.](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
   ```

## Associer IRSA à un compte de service Spark
<a name="job-runs-apache-livy-irsa-spark"></a>

Avant de mapper IRSA à un compte de service Spark, assurez-vous d'avoir effectué les tâches suivantes :
+ Assurez-vous que vous avez terminé de [configurer Apache Livy pour Amazon EMR sur](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-setup.html) EKS et que vous êtes en train [d'installer Apache Livy avec Amazon EMR](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-install.html) sur EKS. 
+ Vous devez disposer d'un fournisseur IAM OpenID Connect (OIDC) existant pour votre cluster. Pour savoir si vous en avez déjà un ou comment en créer un, voir [Créer un fournisseur IAM OIDC pour votre cluster](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html).
+ Assurez-vous d'avoir installé la version 0.171.0 ou ultérieure de la `eksctl` CLI installée ou. AWS CloudShell Pour installer ou mettre à jour`eksctl`, consultez la section [Installation](https://eksctl.io/installation/) de la `eksctl` documentation.

Pour associer IRSA à votre compte de service Spark, procédez comme suit :

1. Utilisez la commande suivante pour obtenir le compte de service 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. Définissez vos variables pour l'espace de noms et le nom du compte de service.

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

1. Utilisez la commande suivante pour créer un fichier de politique de confiance pour le rôle IAM. L'exemple suivant autorise tous les comptes de service de l'espace de noms à utiliser le rôle. Pour ce faire, remplacez `StringEquals` par `StringLike` et remplacez `$service_account` par \$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. Créez le rôle.

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

1. Mappez le serveur ou le compte de service Spark à l'aide de la `eksctl` commande suivante. Assurez-vous d'utiliser vos propres valeurs.

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

# Propriétés d'installation d'Apache Livy sur Amazon EMR sur les versions EKS
<a name="job-runs-apache-livy-installation-properties"></a>

L'installation d'Apache Livy vous permet de sélectionner une version du graphique Livy Helm. Le diagramme Helm propose une variété de propriétés pour personnaliser votre expérience d'installation et de configuration. Ces propriétés sont prises en charge pour Amazon EMR sur EKS versions 7.1.0 et supérieures.

**Topics**
+ [Propriétés d'installation d'Amazon EMR 7.1.0](#job-runs-apache-livy-installation-properties-710)

## Propriétés d'installation d'Amazon EMR 7.1.0
<a name="job-runs-apache-livy-installation-properties-710"></a>

Le tableau suivant décrit toutes les propriétés Livy prises en charge. Lors de l'installation d'Apache Livy, vous pouvez choisir la version du graphique Livy Helm. Pour définir une propriété lors de l'installation, utilisez la commande`--set <property>=<value>`.


| Propriété | Description | Par défaut | 
| --- | --- | --- | 
| image | L'URI de version Amazon EMR du serveur Livy. Il s'agit d'une configuration obligatoire. | "" | 
| Espace de noms Spark | Espace de noms pour exécuter des sessions Livy Spark. Par exemple, spécifiez « livy ». Il s'agit d'une configuration obligatoire. | "" | 
| Nom Override | Entrez un nom au lieu delivy. Le nom est défini comme étiquette pour toutes les ressources Livy | « Livy » | 
| Nom complet Override | Indiquez un nom à utiliser au lieu du nom complet des ressources. | "" | 
| activé par SSL | Active le end-to-end protocole SSL depuis le point de terminaison Livy vers le serveur Livy. | FALSE | 
| Certificat SSL ARN | Si le protocole SSL est activé, il s'agit de l'ARN du certificat ACM pour le NLB créé par le service. | "" | 
| ssl. secretProviderClassNom | Si le protocole SSL est activé, il s'agit du nom de classe du fournisseur secret permettant de sécuriser le NLB pour la connexion au serveur Livy avec SSL. | "" | 
| ssl. keyStoreObjectNom | Si le protocole SSL est activé, le nom de l'objet du certificat keystore dans la classe du fournisseur secret. | "" | 
| ssl. keyPasswordsObjectNom | Si le protocole SSL est activé, nom de l'objet du secret contenant le keystore et le mot de passe clé. | "" | 
| rbac.create | Si vrai, crée des ressources RBAC. | FALSE | 
| Compte de service. Créer | Si c'est vrai, crée un compte de service Livy. | TRUE | 
| Nom du compte de service | Le nom du compte de service à utiliser pour Livy. Si vous ne définissez pas cette propriété et ne créez pas de compte de service, Amazon EMR sur EKS génère automatiquement un nom à l'aide de la propriété fullname override. | "emr-containers-sa-livy" | 
| Compte de service. executionRoleArn | L'ARN du rôle d'exécution du compte de service Livy. | "" | 
| sparkServiceAccount.créer | SI c'est vrai, crée le compte de service Spark dans .Release.Namespace | TRUE | 
| sparkServiceAccount.nom | Le nom du compte de service à utiliser pour Spark. Si vous ne définissez pas cette propriété et ne créez pas de compte de service Spark, Amazon EMR sur EKS génère automatiquement un nom avec le suffixe de la fullnameOverride propriété. -spark-livy | « emr-containers-sa-spark -Livy » | 
| nom du service | Nom du service Livy | "emr-containers-livy" | 
| service.annotations | Annotations du service Livy | \$1\$1 | 
| loadbalancer.enabled | S'il faut créer un équilibreur de charge pour le service Livy utilisé pour exposer le point de terminaison Livy en dehors du cluster Amazon EKS. | FALSE | 
| équilibreur de charge interne | S'il faut configurer le point de terminaison Livy en tant qu'interne au VPC ou externe. La définition de cette propriété pour `FALSE` exposer le point de terminaison à des sources extérieures au VPC. Nous vous recommandons de sécuriser votre terminal avec le protocole TLS/SSL. Pour plus d'informations, consultez la section [Configuration du chiffrement TLS et SSL](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 | La liste des imagePullSecret noms à utiliser pour extraire une image de Livy depuis des référentiels privés. | [] | 
| resources | Les demandes de ressources et les limites pour les conteneurs Livy. | \$1\$1 | 
| nodeSelector | Les nœuds pour lesquels planifier les modules Livy. | \$1\$1 | 
| tolérances | Une liste contenant les tolérances à définir pour les pods Livy. | [] | 
| affinité | Les règles d'affinité des Livy Pods. | \$1\$1 | 
| persistence.enabled | Si vrai, active la persistance pour les répertoires de sessions. | FALSE | 
| Persistence.subPath | Le sous-chemin PVC à monter dans les répertoires de sessions. | "" | 
| Persistance. Réclamation existante | Le PVC à utiliser au lieu d'en créer un nouveau. | \$1\$1 | 
| Persistance. Classe de stockage | Classe de stockage à utiliser. Pour définir ce paramètre, utilisez le formatstorageClassName: <storageClass>. La définition de ce paramètre pour "-" désactiver le provisionnement dynamique. Si vous définissez ce paramètre sur null ou si vous ne spécifiez rien, Amazon EMR sur EKS ne définit pas de fournisseur storageClassName et utilise le fournisseur par défaut. | "" | 
| Persistance. Mode d'accès | Le mode d'accès au PVC. | ReadWriteOnce | 
| persistence.size | La taille du PVC. | 20 Gi | 
| persistence.annotations | Annotations supplémentaires pour le PVC. | \$1\$1 | 
| env. \$1 | Envs supplémentaires à régler sur le conteneur Livy. Pour plus d'informations, voir Saisir [vos propres configurations Livy et Spark lors de l'installation](https://docs.aws.amazon.com/emr/latest/EMR-on-EKS-DevelopmentGuide/job-runs-apache-livy-troubleshooting.html) de Livy. | \$1\$1 | 
| Env à partir de. \$1 | Environnements supplémentaires à définir sur Livy à partir d'une carte de configuration ou d'un secret de Kubernetes. | [] | 
| LivyConf. \$1 | Entrées livy.conf supplémentaires à définir à partir d'une carte ou d'un secret de configuration Kubernetes monté. | \$1\$1 | 
| sparkDefaultsConf.\$1 | spark-defaults.confEntrées supplémentaires à définir à partir d'une carte ou d'un secret de configuration Kubernetes monté. | \$1\$1 | 

# Résoudre les erreurs de format courantes liées aux variables d'environnement
<a name="job-runs-apache-livy-troubleshooting"></a>

Lorsque vous saisissez des configurations Livy et Spark, certains formats de variables d'environnement ne sont pas pris en charge et peuvent provoquer des erreurs. La procédure vous guide à travers une série d'étapes pour vous assurer que vous utilisez les bons formats.

**Entrez vos propres configurations Livy et Spark lors de l'installation de Livy**

Vous pouvez configurer n'importe quelle variable d'environnement Apache Livy ou Apache Spark avec la propriété `env.*` Helm. Suivez les étapes ci-dessous pour convertir l'exemple de configuration dans un format `example.config.with-dash.withUppercase` de variable d'environnement pris en charge.

1. Remplacez les lettres majuscules par un 1 et une minuscule de la lettre. Par exemple, `example.config.with-dash.withUppercase` devient `example.config.with-dash.with1uppercase`.

1. Remplacez les tirets (-) par 0. Par exemple, `example.config.with-dash.with1uppercase` devient `example.config.with0dash.with1uppercase`

1. Remplacez les points (.) par des traits de soulignement (\$1). Par exemple, `example.config.with0dash.with1uppercase` devient `example_config_with0dash_with1uppercase`.

1. Remplacez toutes les lettres minuscules par des lettres majuscules.

1. Ajoutez le préfixe `LIVY_` au nom de la variable.

1. Utilisez la variable lors de l'installation de Livy via le graphique de barre en utilisant le format --set env. *YOUR\$1VARIABLE\$1NAME*.valeur= *yourvalue*

Par exemple, pour définir les configurations Livy et Spark `livy.server.recovery.state-store = filesystem` et utiliser `spark.kubernetes.executor.podNamePrefix = my-prefix` les propriétés Helm suivantes :

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