Surveillance des tâches Spark Modèles de pods personnalisés Déploiement d'un JEG pod sur un groupe de nœuds JEGoptions de configuration Modification des PySpark paramètres Image de noyau personnalisée

Configuration des paramètres pour les points de terminaison interactifs

Surveillance des tâches Spark

Afin de pouvoir surveiller et résoudre les défaillances, configurez vos points de terminaison interactifs afin que les tâches initiées avec le point de terminaison puissent envoyer des informations de journal à Amazon S3, Amazon CloudWatch Logs ou aux deux. Les sections suivantes décrivent comment envoyer les journaux d'applications Spark à Amazon S3 pour les tâches Spark que vous lancez avec Amazon EMR sur des points de terminaison EKS interactifs.

Configuration IAM de la politique pour les journaux Amazon S3

Avant que vos noyaux puissent envoyer des données de journal à Amazon S3, la politique d'autorisations pour le rôle d'exécution des tâches doit inclure les autorisations suivantes. Remplacez DOC-EXAMPLE-BUCKET-LOGGING avec le nom de votre bucket de journalisation.


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:PutObject",
                "s3:GetObject",
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::DOC-EXAMPLE-BUCKET-LOGGING",
                "arn:aws:s3:::DOC-EXAMPLE-BUCKET-LOGGING/*",
            ]
        }
    ]
}

Note

Amazon EMR on EKS peut également créer un compartiment S3. Si aucun compartiment S3 n'est disponible, incluez l's3:CreateBucketautorisation dans la IAM politique.

Une fois que vous avez accordé à votre rôle d'exécution les autorisations nécessaires pour envoyer des journaux au compartiment S3, vos données de journal sont envoyées aux emplacements Amazon S3 suivants. Cela se produit lorsque s3MonitoringConfiguration est transmise dans la section monitoringConfiguration d'une demande create-managed-endpoint.

Journaux de pilote – logUri/virtual-cluster-id/endpoints/endpoint-id/containers/spark-application-id/spark-application-id-driver/(stderr.gz/stdout.gz)
Journaux d'exécuteur – logUri/virtual-cluster-id/endpoints/endpoint-id/containers/spark-application-id/executor-pod-name-exec-<Number>/(stderr.gz/stdout.gz)

Note

Amazon EMR on EKS ne télécharge pas les journaux des terminaux dans votre compartiment S3.

Spécification de modèles de pods personnalisés avec des points de terminaison interactifs

Vous pouvez créer des points de terminaison interactifs dans lesquels vous indiquez des modèles de pods personnalisés pour les pilotes et les exécuteurs. Les modèles de pods sont des spécifications qui déterminent comment exécuter chaque pod. Vous pouvez utiliser des fichiers de modèles de pods pour définir les configurations de pods de pilotes ou d'exécuteurs que les configurations Spark ne prennent pas en charge. Les modèles de pods sont actuellement pris en charge dans les EMR versions 6.3.0 et supérieures d'Amazon.

Pour plus d'informations sur les modèles de modules, consultez la section Utilisation des modèles de modules dans le guide Amazon EMR on EKS Development.

L'exemple suivant montre comment créer un point de terminaison interactif à l'aide de modèles de pods :


aws emr-containers create-managed-endpoint \
    --type JUPYTER_ENTERPRISE_GATEWAY \
    --virtual-cluster-id virtual-cluster-id \
    --name example-endpoint-name \
    --execution-role-arn arn:aws:iam::aws-account-id:role/EKSClusterRole \
    --release-label emr-6.9.0-latest \
    --configuration-overrides '{
        "applicationConfiguration": [
        {
            "classification": "spark-defaults",
            "properties": {
                "spark.kubernetes.driver.podTemplateFile": "path/to/driver/template.yaml",
                "spark.kubernetes.executor.podTemplateFile": "path/to/executor/template.yaml"
            }
        }]
    }'

Déploiement d'un JEG pod sur un groupe de nœuds

JEGLe placement du pod (Jupyter Enterprise Gateway) est une fonctionnalité qui vous permet de déployer un point de terminaison interactif sur un groupe de nœuds spécifique. Grâce à cette fonctionnalité, vous pouvez configurer des paramètres tels que instance type pour le point de terminaison interactif.

Associer un JEG pod à un groupe de nœuds géré

La propriété de configuration suivante vous permet de spécifier le nom d'un groupe de nœuds gérés sur votre EKS cluster Amazon où le JEG pod sera déployé.


//payload 
--configuration-overrides '{
      "applicationConfiguration": [
            {
                "classification": "endpoint-configuration",
                "properties": {
                    "managed-nodegroup-name": NodeGroupName
                }        
            }
        ] 
    }'

Le groupe de nœuds doit avoir l'étiquette Kubernetes for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName attachée à tous les nœuds qui font partie du groupe de nœuds. Pour répertorier tous les nœuds d'un groupe de nœuds dotés de cette balise, utilisez la commande suivante :


kubectl get nodes --show-labels | grep for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName

Si le résultat de la commande ci-dessus ne renvoie pas de nœuds faisant partie de votre groupe de nœuds géré, cela signifie qu'aucun nœud du groupe de nœuds n'a l'étiquette Kubernetes for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName attachée. Dans ce cas, suivez les étapes ci-dessous pour attacher cette étiquette aux nœuds de votre groupe de nœuds.

Utilisez la commande suivante pour ajouter l'étiquette Kubernetes for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName à tous les nœuds d'un groupe de nœuds géré NodeGroupName :
```
kubectl label nodes --selector eks:nodegroup-name=NodeGroupName for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName
```

Vérifiez que les nœuds ont été correctement étiquetés à l'aide de la commande suivante :


kubectl get nodes --show-labels | grep for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName

Un groupe de nœuds gérés doit être associé au groupe de sécurité d'un EKS cluster Amazon, ce qui est généralement le cas si vous avez créé votre cluster et votre groupe de nœuds gérés à l'aide deeksctl. Vous pouvez le vérifier dans la AWS console en procédant comme suit.

Accédez à votre cluster dans la EKS console Amazon.
Allez dans l'onglet de mise en réseau de votre cluster et notez le groupe de sécurité du cluster.
Accédez à l'onglet de calcul de votre cluster et cliquez sur le nom du groupe de nœuds géré.
Dans l'onglet Détails du groupe de nœuds géré, vérifiez que le groupe de sécurité du cluster que vous avez noté précédemment est répertorié sous Groupes de sécurité.

Si le groupe de nœuds gérés n'est pas attaché au groupe de sécurité du EKS cluster Amazon, vous devez associer la for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName balise au groupe de sécurité du groupe de nœuds. Suivez les étapes ci-dessous pour attacher cette étiquette.

Accédez à la EC2 console Amazon et cliquez sur les groupes de sécurité dans le volet de navigation de gauche.
Sélectionnez le groupe de sécurité de votre groupe de nœuds géré en cochant la case.
Sous l'onglet Balises, ajoutez la balise for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName à l'aide du bouton Gérer les balises.

Associer un JEG pod à un groupe de nœuds autogéré

La propriété de configuration suivante vous permet de spécifier le nom d'un groupe de nœuds autogéré ou non géré sur le EKS cluster Amazon où le JEG pod sera déployé.


//payload 
--configuration-overrides '{
      "applicationConfiguration": [
            {
                "classification": "endpoint-configuration",
                "properties": {
                    "self-managed-nodegroup-name": NodeGroupName
                }        
            }
        ] 
    }'


kubectl get nodes --show-labels | grep for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName

Si le résultat de la commande ci-dessus ne renvoie pas de nœuds faisant partie de votre groupe de nœuds autogéré, cela signifie qu'aucun nœud du groupe de nœuds n'a l'étiquette Kubernetes for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName attachée. Dans ce cas, suivez les étapes ci-dessous pour attacher cette étiquette aux nœuds de votre groupe de nœuds.

Si vous avez créé le groupe de nœuds autogéré à l'aide de l'outil eksctl, utilisez la commande suivante pour ajouter l'étiquette Kubernetes for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName à tous les nœuds du groupe de nœuds autogéré NodeGroupName en une seule fois.
```
kubectl label nodes --selector alpha.eksctl.io/nodegroup-name=NodeGroupName for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName
```
Si vous n'avez pas utilisé eksctl pour créer le groupe de nœuds autogéré, vous devrez remplacer le sélecteur dans la commande ci-dessus par une étiquette Kubernetes différente qui est attachée à tous les nœuds du groupe de nœuds.

Utilisez la commande suivante pour vérifier que les nœuds ont été étiquetés correctement :


kubectl get nodes --show-labels | grep for-use-with-emr-containers-managed-endpoint-ng=NodeGroupName

Le groupe de sécurité du groupe de nœuds autogérés doit avoir la balise for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName attachée. Procédez comme suit pour attacher la balise au groupe de sécurité à partir de la AWS Management Console.

Accédez à la EC2 console Amazon. Dans le volet de navigation de gauche, sélectionnez Groupes de sécurité.
Cochez la case à côté du groupe de sécurité pour votre groupe de nœuds autogéré.
Sous l'onglet Balises, utilisez le bouton Gérer les balises pour ajouter la balise for-use-with-emr-containers-managed-endpoint-sg=ClusterName/NodeGroupName. Remplacez ClusterName et NodeGroupName par les valeurs appropriées.

Associer un JEG pod à un groupe de nœuds géré avec des instances à la demande

Vous pouvez également définir des étiquettes supplémentaires, appelées sélecteurs d'étiquettes Kubernetes, afin de spécifier des contraintes ou des restrictions supplémentaires pour exécuter un point de terminaison interactif sur un nœud ou un groupe de nœuds donné. L'exemple suivant montre comment utiliser des EC2 instances Amazon On-Demand pour un JEG pod.


--configuration-overrides '{
      "applicationConfiguration": [
            {
                "classification": "endpoint-configuration",
                "properties": {
                    "managed-nodegroup-name": NodeGroupName,
                    "node-labels": "eks.amazonaws.com/capacityType:ON_DEMAND"
                }        
            }
        ] 
    }'

Note

Vous ne pouvez utiliser la propriété node-labels qu'avec une propriété managed-nodegroup-name ou self-managed-nodegroup-name.

Options de configuration de Jupyter Enterprise Gateway (JEG)

Amazon EMR on EKS utilise Jupyter Enterprise Gateway (JEG) pour activer les points de terminaison interactifs. Vous pouvez définir les valeurs suivantes pour les JEG configurations autorisées lorsque vous créez le point de terminaison.

RemoteMappingKernelManager.cull_idle_timeout : délai d'expiration en secondes (entier), après quoi un noyau est considéré comme inactif et prêt à être éliminé. Les valeurs de 0 ou moins désactivent l'élimination. Des délais d'expiration trop courts risquent d'entraîner l'élimination des noyaux pour les utilisateurs disposant de connexions réseau médiocres.
RemoteMappingKernelManager.cull_interval : intervalle en secondes (entier) pendant lequel il faut vérifier si les noyaux inactifs dépassent la valeur du délai d'élimination.

Modification des paramètres PySpark de session

À partir de EMR la EKS version 6.9.0 d'Amazon, dans Amazon EMR Studio, vous pouvez ajuster la configuration Spark associée à une PySpark session en exécutant la commande %%configure magique dans la cellule du EMR bloc-notes.

L'exemple suivant montre un exemple de charge utile que vous pouvez utiliser pour modifier la mémoire, les cœurs et d'autres propriétés du pilote et de l'exécuteur Spark. Pour les paramètres conf, vous pouvez configurer n'importe quelle configuration Spark mentionnée dans la documentation de configuration d'Apache Spark.


%%configure -f
{
  "driverMemory": "16G",
  "driverCores" 4,
  "executorMemory" : "32G"
  "executorCores": 2,
  "conf": {
     "spark.dynamicAllocation.maxExecutors" : 10,
     "spark.dynamicAllocation.minExecutors": 1
  }
}

L'exemple suivant montre un exemple de charge utile que vous pouvez utiliser pour ajouter des fichiers et des dépendances JAR à un environnement d'exécution Spark. pyFiles


%%configure -f
{
  "files": "s3://test-bucket-emr-eks/sample_file.txt",
  "pyFiles": : "path-to-python-files",
  "jars" : "path-to-jars
}

Image de noyau personnalisée avec point de terminaison interactif

Pour garantir que vous disposez des dépendances appropriées pour votre application lorsque vous exécutez des charges de travail interactives depuis Amazon EMR Studio, vous pouvez personnaliser les images Docker pour les points de terminaison interactifs et exécuter des images de noyau de base personnalisées. Pour créer un point de terminaison interactif et le connecter à une image Docker personnalisée, suivez les étapes ci-dessous.

Note

Vous ne pouvez remplacer que les images de base. Vous ne pouvez pas ajouter de nouveaux types d'images de noyau.

Créez et publiez une image Docker personnalisée. L'image de base contient le moteur d'exécution Spark et les noyaux de bloc-notes qui s'exécutent avec celui-ci. Pour créer l'image, vous pouvez suivre les étapes 1 à 4 dans Instructions de personnalisation des images Docker. À l'étape 1, l'image de base URI de votre fichier Docker doit être utilisée notebook-spark à la place despark.
```
ECR-registry-account.dkr.ecr.Region.amazonaws.com/notebook-spark/container-image-tag
```
Pour plus d'informations sur la manière de sélectionner Régions AWS et de contenir des balises d'image, consultezComment sélectionner une image de base URI.

Créez un point de terminaison interactif qui peut être utilisé avec l'image personnalisée.

Créez un JSON fichier custom-image-managed-endpoint.json avec le contenu suivant. Cet exemple utilise la EMR version 6.9.0 d'Amazon.


{
    "name": "endpoint-name",
    "virtualClusterId": "virtual-cluster-id",
    "type": "JUPYTER_ENTERPRISE_GATEWAY",
    "releaseLabel": "emr-6.9.0-latest",
    "executionRoleArn": "execution-role-arn",
    "configurationOverrides": {
        "applicationConfiguration": [
            {
                "classification": "jupyter-kernel-overrides",
                "configurations": [
                    {
                        "classification": "python3",
                        "properties": {
                            "container-image": "123456789012.dkr.ecr.us-west-2.amazonaws.com/custom-notebook-python:latest"
                        }
                    },
                    {
                        "classification": "spark-python-kubernetes",
                        "properties": {
                            "container-image": "123456789012.dkr.ecr.us-west-2.amazonaws.com/custom-notebook-spark:latest"
                        }
                    }
                ] 
            }
        ]
    }
}

Créez un point de terminaison interactif avec les configurations spécifiées dans le JSON fichier, comme indiqué dans l'exemple suivant. Pour de plus amples informations, veuillez consulter Création d'un point de terminaison interactif à l'aide de la commande create-managed-endpoint.
```
aws emr-containers create-managed-endpoint --cli-input-json custom-image-managed-endpoint.json
```

Connectez-vous au point de terminaison interactif via EMR Studio. Pour plus d'informations et pour connaître les étapes à suivre, consultez la EKS section Connexion depuis Studio EMR sur Amazon dans la documentation de AWS Workshop Studio.

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Création d'un point de terminaison interactif

Surveillance des points de terminaison interactifs