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.
# Tâches
Les emplois sont l'unité de travail créée par AWS Batch. Les tâches peuvent être invoquées sous forme d'applications conteneurisées qui s'exécutent sur des instances de conteneur Amazon ECS dans un cluster ECS.
Les tâches de conteneurs peuvent référencer une image, une commande et des paramètres de conteneur. Pour de plus amples informations, veuillez consulter [JobDefinition](https://docs.aws.amazon.com/batch/latest/APIReference/API_JobDefinition.html).
Vous pouvez soumettre un grand nombre de tâches simples indépendantes.
**Topics**
+ [Tutoriel : soumettre une offre d'emploi](submit_job.md)
+ [Emplois de service à AWS Batch](service-jobs.md)
+ [États de l'emploi](job_states.md)
+ [AWS Batch variables d'environnement de travail](job_env_vars.md)
+ [Nouvelles tentatives de travail automatisées](job_retries.md)
+ [Dépendances professionnelles](job_dependencies.md)
+ [Expiration des délais d'exécution des tâches](job_timeouts.md)
+ [Offres d'emploi Amazon EKS](eks-jobs.md)
+ [Tâches parallèles sur plusieurs nœuds](multi-node-parallel-jobs.md)
+ [Tâches parallèles à nœuds multiples sur Amazon EKS](mnp-eks-jobs.md)
+ [Tâches liées à](array_jobs.md)
+ [Exécuter des tâches GPU](gpu-jobs.md)
+ [Afficher les AWS Batch tâches dans une file d'attente](view-jobs.md)
+ [Rechercher AWS Batch des offres d'emploi dans une file d'attente](searching-filtering-jobs.md)
+ [Modes de mise en réseau pour les AWS Batch tâches](networking-modes-jobs.md)
+ [Afficher les journaux des AWS Batch tâches dans CloudWatch Logs](review-job-logs.md)
+ [Consulter les informations relatives à l' AWS Batch emploi](review-job-info.md)
# Tutoriel : soumettre une offre d'emploi
Après avoir enregistré une définition de tâche, vous pouvez la soumettre en tant que tâche à une file d'attente de AWS Batch tâches. Vous pouvez remplacer de nombreux paramètres spécifiés dans la définition de la tâche lors de l'exécution.
**Pour soumettre une tâche**
1. Ouvrez la AWS Batch console à l'adresse [https://console.aws.amazon.com/batch/](https://console.aws.amazon.com/batch/).
1. Dans la barre de navigation, sélectionnez le Région AWS à utiliser.
1. Dans le volet de navigation, sélectionnez **Tâches**.
1. Choisissez **Soumettre un nouveau travail**.
1. Dans **Nom**, entrez un nom unique pour votre définition de tâche. Le nom peut comporter jusqu'à 128 caractères. Il peut contenir des lettres majuscules et minuscules, des chiffres, des traits d'union (-) et des traits de soulignement (\$1).
1. Pour **Définition du travail**, choisissez une définition de tâche existante pour votre tâche. Pour de plus amples informations, veuillez consulter [Création d'une définition de tâche à nœud unique](create-job-definition.md).
1. Pour la **file d'attente de tâches**, choisissez une file d'attente de tâches existante. Pour de plus amples informations, veuillez consulter [Création d'une file d'attente de tâches](create-job-queue.md).
1. Pour les **dépendances des tâches**, sélectionnez **Ajouter des dépendances des tâches**.
1. Dans le **champ Job id**, entrez l'ID du job pour toutes les dépendances. Choisissez ensuite **Ajouter des dépendances de tâches**. Une tâche peut comporter jusqu'à 20 dépendances. Pour de plus amples informations, veuillez consulter [Dépendances professionnelles](job_dependencies.md).
1. (Tâches de tableau uniquement) Pour **Taille du tableau**, spécifiez une taille de tableau entre 2 et 10 000.
1. (Facultatif) Développez les **balises**, puis choisissez **Ajouter une balise** pour ajouter des balises à la ressource. Entrez une clé et une valeur facultative, puis choisissez **Ajouter une étiquette**.
1. Choisissez **Page suivante**.
1. Dans la section **Job overrides** :
1.
(Facultatif) Pour **Priorité de planification**, entrez une valeur de priorité de planification comprise entre 0 et 100. Les valeurs les plus élevées reçoivent une priorité plus élevée.
1. (Facultatif) Pour les **tentatives de tâche**, entrez le nombre maximal de AWS Batch tentatives de transfert de la tâche vers un `RUNNABLE` statut. Vous pouvez saisir un nombre compris entre 1 et 10. Pour de plus amples informations, veuillez consulter [Nouvelles tentatives de travail automatisées](job_retries.md).
1. (Facultatif) Pour le **délai d'exécution**, entrez la valeur du délai d'expiration (en secondes). Le délai d'exécution est le délai avant la fin d'une tâche inachevée. Si une tentative dépasse le délai imparti, elle est arrêtée et passe à un `FAILED` statut. Pour de plus amples informations, veuillez consulter [Expiration des délais d'exécution des tâches](job_timeouts.md). La valeur minimale est 60 secondes.
**Important**
Ne comptez pas sur les tâches exécutées sur les ressources de Fargate pour qu'elles s'exécutent pendant plus de 14 jours. Après 14 jours, il est possible que les ressources de Fargate ne soient plus disponibles et que le travail soit probablement résilié.
1. (Facultatif) Activez les **balises de propagation** pour propager les balises de la tâche et de la définition de la tâche vers la tâche Amazon ECS.
1. Développez **Additional configuration (Configuration supplémentaire)**.
1. (Facultatif) Pour les **conditions de la stratégie Réessayer**, choisissez **Ajouter une évaluation à la sortie**. Entrez au moins une valeur de paramètre, puis choisissez une **action**. Pour chaque ensemble de conditions, l'**action** doit être définie sur **Réessayer** ou sur **Quitter**. Ces actions signifient ce qui suit :
+ **Réessayer** — AWS Batch Réessaie jusqu'à ce que le nombre de tentatives de travail que vous avez spécifié soit atteint.
+ **Quitter** : AWS Batch arrête de réessayer la tâche.
**Important**
Si vous choisissez **Ajouter une évaluation à la sortie**, configurez au moins un paramètre et choisissez soit une **action**, soit **Supprimer l'évaluation à la sortie**.
1. Pour **Paramètres**, choisissez **Ajouter des paramètres pour ajouter** des espaces réservés pour la substitution de paramètres. Entrez ensuite une **clé** et une **valeur** facultative.
1. Dans la section **Dérogations de conteneurs** :
1. Pour **Command**, entrez les commandes dans le champ en tant qu'équivalent dans un tableau de chaînes **JSON**.
Ce paramètre correspond à `Cmd` dans la section [Create a container (Création d'un conteneur)](https://docs.docker.com/engine/api/v1.38/#operation/ContainerCreate) de [Docker Remote API (API distante Docker)](https://docs.docker.com/engine/api/v1.38/) et au paramètre `COMMAND` de [https://docs.docker.com/engine/reference/commandline/run/](https://docs.docker.com/engine/reference/commandline/run/). Pour plus d'informations sur le `CMD` paramètre Docker, consultez [https://docs.docker.com/engine/reference/builder/](https://docs.docker.com/engine/reference/builder/#cmd) \$1cmd.
**Note**
Ce paramètre ne peut pas contenir de chaîne vide.
1. Pour **v CPUs**, entrez le nombre de v CPUs à réserver pour le conteneur. Ce paramètre correspond à `CpuShares` dans la section [Create a container](https://docs.docker.com/engine/api/v1.38/#operation/ContainerCreate) (Créer un conteneur) de l'[API Docker à distance](https://docs.docker.com/engine/api/v1.38/) et l'option `--cpu-shares` correspond à [https://docs.docker.com/engine/reference/commandline/run/](https://docs.docker.com/engine/reference/commandline/run/). Chaque processeur virtuel est équivalente à 1 024 parts de processeur. Vous devez spécifier au moins un vCPU.
1. Pour **Mémoire**, entrez la limite de mémoire disponible pour le conteneur. Si votre conteneur tente de dépasser la mémoire spécifiée ici, il est arrêté. Ce paramètre correspond à `Memory` dans la section [Create a container](https://docs.docker.com/engine/api/v1.38/#operation/ContainerCreate) (Créer un conteneur) de l'[API Docker à distance](https://docs.docker.com/engine/api/v1.38/) et l'option `--memory` correspond à [https://docs.docker.com/engine/reference/commandline/run/](https://docs.docker.com/engine/reference/commandline/run/). Vous devez spécifier au moins 4 Mio de mémoire pour une tâche.
**Note**
Pour optimiser l'utilisation de vos ressources, donnez la priorité à la mémoire pour les tâches d'un type d'instance spécifique. Pour de plus amples informations, veuillez consulter [Gestion de la mémoire des ressources informatiques](memory-management.md).
1. (Facultatif) **Dans Nombre de GPUs**, choisissez le nombre de GPUs à réserver pour le conteneur.
1. (Facultatif) Pour les **variables d'environnement**, choisissez **Ajouter une variable d'environnement** pour ajouter des variables d'environnement sous forme de paires nom-valeur. Ces variables sont transmises au conteneur.
1. Choisissez **Page suivante**.
1. Pour la **révision du Job**, passez en revue les étapes de configuration. Si vous devez apporter des modifications, choisissez **Modifier**. Lorsque vous avez terminé, choisissez **Créer une définition de tâche**.
# Emplois de service à AWS Batch
AWS Batch les tâches de service vous permettent de soumettre des demandes aux AWS services par le biais de files AWS Batch d'attente de travail. Actuellement, AWS Batch soutient les emplois SageMaker de formation en tant qu'emplois de service. Contrairement aux tâches conteneurisées AWS Batch qui gèrent l'exécution du conteneur sous-jacent, les tâches de service permettent de AWS Batch fournir des fonctionnalités de planification des tâches et de mise en file d'attente tandis que le AWS service cible (tel que l' SageMaker IA) gère l'exécution réelle des tâches.
AWS Batch for SageMaker Training jobs permet aux data scientists de soumettre des tâches de formation prioritaires à des files d'attente configurables, garantissant ainsi l'exécution des charges de travail sans intervention dès que les ressources sont disponibles. Cette fonctionnalité permet de relever des défis courants tels que la coordination des ressources, la prévention des dépenses excessives accidentelles, le respect des contraintes budgétaires, l'optimisation des coûts grâce aux instances réservées et l'élimination du besoin de coordination manuelle entre les membres de l'équipe.
Les tâches de service diffèrent des tâches conteneurisées de plusieurs manières principales :
+ **Soumission** de tâches : les tâches de service doivent être soumises à l'aide de l'[SubmitServiceJob](https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitServiceJob.html)API. Les tâches de service ne peuvent pas être soumises via la AWS Batch console.
+ **Exécution des tâches** : AWS Batch planifie et met en file d'attente les tâches de service, mais le AWS service cible exécute la charge de travail réelle des tâches.
+ **Identifiants de ressources : les** tâches de service ARNs contiennent « tâche de service » au lieu de « tâche » pour les distinguer des tâches conteneurisées.
Pour commencer à travailler sur les emplois AWS Batch de service pour SageMaker la formation, voir[Commencer à utiliser AWS Batch l' SageMaker IA](getting-started-sagemaker.md).
**Topics**
+ [Charges utiles des tâches de maintenance dans AWS Batch](service-job-payload.md)
+ [Soumettre une offre d'emploi dans le secteur des services AWS Batch](service-job-submit.md)
+ [Mappage AWS Batch de l'état de la tâche du service avec SageMaker le statut de](service-job-status.md)
+ [Stratégies de nouvelle tentative d'emploi dans AWS Batch](service-job-retries.md)
+ [Surveiller les tâches de service dans une AWS Batch file d'attente](monitor-sagemaker-job-queue.md)
+ [Mettre fin à des tâches de service](terminate-service-jobs.md)
# Charges utiles des tâches de maintenance dans AWS Batch
Lorsque vous soumettez des tâches de service à l'aide de [SubmitServiceJob](https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitServiceJob.html), vous fournissez deux paramètres clés qui définissent la tâche : `serviceJobType` et`serviceRequestPayload`.
+ `serviceJobType`Spécifie le AWS service qui exécutera la tâche. Pour les tâches de SageMaker formation, cette valeur est`SAGEMAKER_TRAINING`.
+ `serviceRequestPayload`Il s'agit d'une chaîne codée en JSON qui contient la demande complète qui serait normalement envoyée directement au service cible. Pour les tâches de SageMaker formation, cette charge utile contient les mêmes paramètres que ceux que vous utiliseriez avec l'[CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)API SageMaker AI.
Pour obtenir la liste complète de tous les paramètres disponibles et leurs descriptions, consultez la référence de l'[CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)API SageMaker AI. Tous les paramètres pris en charge par `CreateTrainingJob` peuvent être inclus dans la charge utile de votre tâche de service.
Pour des exemples de configurations de tâches de formation supplémentaires [APIs, consultez la CLI et SDKs](https://docs.aws.amazon.com/sagemaker/latest/dg/api-and-sdk-reference-overview.html) le [Guide du développeur d'SageMaker IA](https://docs.aws.amazon.com/sagemaker/latest/dg/gs.html).
Nous vous recommandons d'utiliser le PySDK pour créer des tâches de service, car PySDK possède des classes d'assistance et des utilitaires. Pour un exemple d'utilisation de PySDK, consultez les [exemples d'SageMaker IA](https://github.com/aws/amazon-sagemaker-examples) sur. GitHub
## Exemple de charge utile d'une tâche de service
L'exemple suivant montre une charge utile d'une tâche de service simple pour une tâche de SageMaker formation qui exécute un script de formation « hello world » :
Cette charge utile serait transmise sous forme de chaîne JSON au `serviceRequestPayload` paramètre lors de l'appel`SubmitServiceJob`.
```
{
"TrainingJobName": "my-simple-training-job",
"RoleArn": "arn:aws:iam::123456789012:role/SageMakerExecutionRole",
"AlgorithmSpecification": {
"TrainingInputMode": "File",
"TrainingImage": "763104351884.dkr.ecr.us-west-2.amazonaws.com/pytorch-training:2.0.0-cpu-py310",
"ContainerEntrypoint": [
"echo",
"hello world"
]
},
"ResourceConfig": {
"InstanceType": "ml.c5.xlarge",
"InstanceCount": 1,
"VolumeSizeInGB": 1
},
"OutputDataConfig": {
"S3OutputPath": "s3://your-output-bucket/output"
},
"StoppingCondition": {
"MaxRuntimeInSeconds": 30
}
}
```
# Soumettre une offre d'emploi dans le secteur des services AWS Batch
Pour soumettre des tâches de service à AWS Batch, vous utilisez l'[SubmitServiceJob](https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitServiceJob.html)API. Vous pouvez soumettre des tâches à l'aide du AWS CLI ou du SDK.
Si vous n'avez pas encore de rôle d'exécution, vous devez en créer un avant de pouvoir soumettre votre tâche de service. Pour créer le rôle d'exécution SageMaker AI, voir [Comment utiliser les rôles d'exécution SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html) dans le *[guide SageMaker AI Developer](https://docs.aws.amazon.com/sagemaker/latest/dg/whatis.html)*.
## Flux de travail de soumission des tâches de service
Lorsque vous soumettez une tâche de service, suivez AWS Batch ce flux de travail :
1. AWS Batch reçoit votre `[SubmitServiceJob](https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitServiceJob.html)` demande et valide les paramètres AWS Batch spécifiques. Le `serviceRequestPayload` est transmis sans validation.
1. La tâche entre dans l'`SUBMITTED`état et est placée dans la file d'attente de tâches spécifiée
1. AWS Batch évalue s'il existe une capacité disponible dans l'environnement de service pour les `RUNNABLE` tâches situées en tête de file
1. Si la capacité est disponible, le travail est transféré à AI `SCHEDULED` et le travail a été transmis à l' SageMaker IA
1. Lorsque la capacité a été acquise et que l' SageMaker IA a téléchargé les données de la tâche de service, l'initialisation de la tâche de service commence et la tâche est remplacée par. `STARTING`
1. Lorsque SageMaker l'IA commence à exécuter la tâche, son statut passe à`RUNNING`.
1. Pendant que l' SageMaker IA exécute la tâche, AWS Batch surveille sa progression et fait correspondre les états du service aux états des AWS Batch tâches. Pour plus de détails sur la façon dont les états des tâches de service sont mappés, voir [Mappage AWS Batch de l'état de la tâche du service avec SageMaker le statut de](service-job-status.md)
1. Lorsque la tâche de service est terminée, elle est `SUCCEEDED` déplacée vers et toute sortie est prête à être téléchargée.
## Conditions préalables
Avant de soumettre une demande de service, assurez-vous d'avoir :
+ **Environnement de service : environnement** de service qui définit les limites de capacité. Pour de plus amples informations, veuillez consulter [Créez un environnement de service dans AWS Batch](create-service-environments.md).
+ **SageMaker file d'attente** de SageMaker tâches : file d'attente de tâches permettant de planifier les tâches. Pour de plus amples informations, veuillez consulter [Créez une file d'attente SageMaker de tâches de formation dans AWS Batch](create-sagemaker-job-queue.md).
+ Autorisations **IAM : autorisations** permettant de créer et de gérer des files AWS Batch d'attente de travail et des environnements de service. Pour de plus amples informations, veuillez consulter [AWS Batch Politiques, rôles et autorisations IAM](IAM_policies.md).
## Soumettre une tâche de service avec la AWS CLI
Voici comment soumettre une tâche de service à l'aide de la AWS CLI :
```
aws batch submit-service-job \
--job-name "my-sagemaker-training-job" \
--job-queue "my-sagemaker-job-queue" \
--service-job-type "SAGEMAKER_TRAINING" \
--service-request-payload '{\"TrainingJobName\": \"sagemaker-training-job-example\", \"AlgorithmSpecification\": {\"TrainingImage\": \"123456789012.dkr.ecr.us-east-1.amazonaws.com/pytorch-inference:1.8.0-cpu-py3\", \"TrainingInputMode\": \"File\", \"ContainerEntrypoint\": [\"sleep\", \"1\"]}, \"RoleArn\":\"arn:aws:iam::123456789012:role/SageMakerExecutionRole\", \"OutputDataConfig\": {\"S3OutputPath\": \"s3://example-bucket/model-output/\"}, \"ResourceConfig\": {\"InstanceType\": \"ml.m5.large\", \"InstanceCount\": 1, \"VolumeSizeInGB\": 1}}'
--client-token "unique-token-12345"
```
Pour plus d'informations sur les `serviceRequestPayload` paramètres, consultez[Charges utiles des tâches de maintenance dans AWS Batch](service-job-payload.md).
# Mappage AWS Batch de l'état de la tâche du service avec SageMaker le statut de
Lorsque vous soumettez des tâches à une file d'attente de SageMaker tâches en utilisant [SubmitServiceJob](https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitServiceJob.html), AWS Batch gère le cycle de vie des tâches et mappe [les états des AWS Batch tâches aux états](job_states.md) des tâches de SageMaker formation équivalents. Les tâches de service, telles que les tâches de SageMaker formation, suivent un cycle de vie différent de celui des tâches traditionnelles liées aux conteneurs. Bien que les tâches de service partagent la plupart des États avec les tâches de conteneur, elles introduisent l'`SCHEDULED`état et présentent des comportements de nouvelle tentative différents, en particulier pour gérer les erreurs de capacité insuffisante du service cible.
Le tableau suivant indique l'état de la AWS Batch tâche et le SageMaker statut/ correspondant : SecondaryStatus
| État du lot | SageMaker État principal de l'IA | SageMaker Statut secondaire de l'IA | Description |
| --- | --- | --- | --- |
| SUBMITTED | N/A | N/A | Job soumis à la file d'attente, en attente d'évaluation par le planificateur. |
| RUNNABLE | N/A | N/A | Job est en file d'attente et prêt à être planifié. Les emplois dans cet état sont démarrés dès que des ressources suffisantes sont disponibles dans l'environnement de service. Les emplois peuvent rester dans cet état indéfiniment lorsque des ressources suffisantes ne sont pas disponibles. |
| SCHEDULED | InProgress | Pending | Tâche de service soumise avec succès à l' SageMaker IA |
| STARTING | InProgress | Downloading | SageMaker Tâche de formation : téléchargement de données et d'images. La capacité des tâches de formation a été acquise et l'initialisation des tâches commence. |
| RUNNING | InProgress | Training | SageMaker Algorithme d'exécution des tâches de formation |
| RUNNING | InProgress | Uploading | SageMaker Tâche de formation : téléchargement d'artefacts de sortie une fois la formation terminée |
| SUCCEEDED | Completed | Completed | SageMaker Tâche de formation terminée avec succès. Le chargement des artefacts de sortie est terminé. |
| FAILED | Failed | Failed | SageMaker La tâche de formation a rencontré une erreur irrécupérable. |
| FAILED | Stopped | Stopped | SageMaker L'utilisation de la tâche de formation a été arrêtée manuellementStopTrainingJob. |
# Stratégies de nouvelle tentative d'emploi dans AWS Batch
Les stratégies de relance des tâches de service permettent AWS Batch de réessayer automatiquement les tâches de service ayant échoué dans des conditions spécifiques.
Les tâches de service peuvent nécessiter plusieurs tentatives pour plusieurs raisons :
+ **Problèmes de service temporaires : des** erreurs de service internes, des ralentissements ou des interruptions temporaires peuvent entraîner l'échec des tâches lors de leur soumission ou de leur exécution.
+ **Échec de l'initialisation de l'entraînement** : les problèmes rencontrés lors du démarrage de la tâche, tels que les problèmes d'extraction d'images ou les erreurs d'initialisation, peuvent être résolus lors d'une nouvelle tentative.
En configurant des stratégies de relance appropriées, vous pouvez améliorer les taux de réussite des tâches et réduire le besoin d'intervention manuelle, en particulier pour les charges de travail de formation de longue durée.
**Note**
Les tâches de service réessayent automatiquement certains types d'échecs, tels que les erreurs de capacité insuffisante, sans que les tentatives de nouvelle tentative configurées soient épuisées. Votre stratégie de nouvelle tentative gère principalement d'autres types d'échecs, tels que les erreurs d'algorithme ou les problèmes de service.
## Configuration des stratégies de nouvelle tentative
Les stratégies de nouvelles tentatives des tâches de service sont configurées à l'aide de [ServiceJobRetryStrategy](https://docs.aws.amazon.com/batch/latest/APIReference/API_ServiceJobRetryStrategy.html), qui prend en charge à la fois le nombre de tentatives simples et la logique de nouvelles tentatives conditionnelles.
### Nouvelle tentative de configuration
La stratégie de nouvelle tentative la plus simple indique le nombre de nouvelles tentatives à effectuer en cas d'échec d'une tâche de service :
```
{
"retryStrategy": {
"attempts": 3
}
}
```
Cette configuration permet de retenter la tâche de service jusqu'à 3 fois en cas d'échec.
**Important**
La `attempts` valeur représente le nombre total de fois que la tâche peut être placée dans `RUNNABLE` cet état, y compris la tentative initiale. Une valeur de 3 signifie que la tâche sera tentée une seule fois au départ, puis réessayée jusqu'à 2 fois en cas d'échec.
### Réessayez la configuration avec evaluateOnExit
Vous pouvez utiliser le `evaluateOnExit` paramètre pour spécifier les conditions dans lesquelles les tâches doivent être réessayées ou autorisées à échouer. Cela est utile lorsque différents types de défaillances nécessitent un traitement différent.
Le `evaluateOnExit` tableau peut contenir jusqu'à 5 stratégies de nouvelle tentative, chacune spécifiant une action (`RETRY`ou`EXIT`) et des conditions basées sur des raisons de statut :
```
{
"retryStrategy": {
"attempts": 5,
"evaluateOnExit": [
{
"action": "RETRY",
"onStatusReason": "Received status from SageMaker: InternalServerError*"
},
{
"action": "EXIT",
"onStatusReason": "Received status from SageMaker: ValidationException*"
},
{
"action": "EXIT",
"onStatusReason": "*"
}
]
}
}
```
Cette configuration :
+ Réessaie les tâches qui échouent en raison d'erreurs internes au serveur SageMaker AI
+ Échoue immédiatement les tâches qui rencontrent des exceptions de validation (erreurs du client qui ne seront pas résolues par une nouvelle tentative)
+ Inclut une règle fourre-tout permettant de remédier à tout autre type de défaillance
#### Correspondance entre le statut et le motif
Le `onStatusReason` paramètre prend en charge la correspondance de modèles comportant jusqu'à 512 caractères. Les modèles peuvent utiliser des caractères génériques (\$1) et correspondre aux raisons de statut renvoyées par l' SageMaker IA.
Pour les tâches de service, les messages d'état provenant de l' SageMaker IA sont précédés du préfixe « Statut reçu de SageMaker : » pour les distinguer des messages AWS Batch générés. Les modèles courants incluent :
+ `Received status from SageMaker: InternalServerError*`- Corrigez les erreurs de service internes
+ `Received status from SageMaker: ValidationException*`- Correspond aux erreurs de validation du client
+ `Received status from SageMaker: ResourceLimitExceeded*`- Correspond aux erreurs de limite de ressources
+ `*CapacityError*`- Correspondre aux défaillances liées à la capacité
**Astuce**
Utilisez des modèles de correspondance spécifiques pour gérer les différents types d'erreur de manière appropriée. Par exemple, réessayez en cas d'erreur interne au serveur, mais échouez immédiatement en cas d'erreur de validation indiquant des problèmes liés aux paramètres de la tâche.
# Surveiller les tâches de service dans une AWS Batch file d'attente
Vous pouvez suivre le statut des tâches de votre file d'attente de SageMaker formation à l'aide de`list-service-jobs`, et`get-job-queue-snapshot`.
Consultez les tâches en cours dans votre file d'attente :
```
aws batch list-service-jobs \
--job-queue my-sm-training-fifo-jq \
--job-status RUNNING
```
Consultez les offres d'emploi en attente :
```
aws batch list-service-jobs \
--job-queue my-sm-training-fifo-jq \
--job-status RUNNABLE
```
Afficher les tâches qui ont été soumises SageMaker mais qui ne sont pas encore en cours d'exécution :
```
aws batch list-service-jobs \
--job-queue my-sm-training-fifo-jq \
--job-status SCHEDULED
```
Obtenez un aperçu des offres d'emploi figurant en tête de liste :
```
aws batch get-job-queue-snapshot --job-queue my-sm-training-fifo-jq
```
Cette commande indique l'ordre des tâches de service à venir dans votre file d'attente.
## Obtenez des informations détaillées sur les tâches de service
Utilisez cette [https://docs.aws.amazon.com/batch/latest/APIReference/API_DescribeServiceJob.html](https://docs.aws.amazon.com/batch/latest/APIReference/API_DescribeServiceJob.html)opération pour obtenir des informations complètes sur une tâche de service spécifique, notamment son statut actuel, les identifiants des ressources de service et des informations détaillées sur les tentatives.
Afficher des informations détaillées sur une tâche spécifique :
```
aws batch describe-service-job \
--job-id a4d6c728-8ee8-4c65-8e2a-9a5e8f4b7c3d
```
Cette commande renvoie des informations complètes sur la tâche, notamment :
+ Job ARN et statut actuel
+ Identifiants de ressources de service (tels que l'ARN de SageMaker la tâche de formation)
+ Planification de la priorité et configuration des nouvelles tentatives
+ Charge utile de la demande de service contenant les paramètres de service d'origine
+ Informations détaillées sur les tentatives avec heures de début et d'arrêt
+ Messages d'état provenant du service cible
## Surveiller les offres SageMaker de formation
Lorsque vous SageMaker surveillez les tâches de formation AWS Batch, vous pouvez accéder à la fois aux informations relatives aux AWS Batch tâches et aux détails des tâches de SageMaker formation sous-jacentes.
L'identifiant de ressource de service indiqué dans les détails de la tâche contient l'ARN de la tâche de SageMaker formation :
```
{
"latestAttempt": {
"serviceResourceId": {
"name": "TrainingJobArn",
"value": "arn:aws:sagemaker:us-east-1:123456789012:training-job/my-training-job"
}
}
}
```
Vous pouvez utiliser cet ARN pour obtenir des informations supplémentaires directement auprès de SageMaker :
```
aws sagemaker describe-training-job \
--training-job-name my-training-job
```
Surveillez l'avancement des tâches en vérifiant à la fois AWS Batch le statut et le statut des tâches de SageMaker formation. Le statut du AWS Batch poste indique le cycle de vie global du travail, tandis que le statut du poste de SageMaker formation fournit des informations spécifiques au service sur le processus de formation.
# Mettre fin à des tâches de service
Utilisez cette [https://docs.aws.amazon.com/batch/latest/APIReference/API_TerminateServiceJob.html](https://docs.aws.amazon.com/batch/latest/APIReference/API_TerminateServiceJob.html)opération pour arrêter une tâche de service en cours d'exécution.
Mettre fin à une tâche de service spécifique :
```
aws batch terminate-service-job \
--job-id a4d6c728-8ee8-4c65-8e2a-9a5e8f4b7c3d \
--reason "Job terminated by user request"
```
Lorsque vous mettez fin à une tâche de service, AWS Batch arrête la tâche et avertissez le service cible. Pour les emplois de SageMaker formation, cela arrêtera également le travail de formation en SageMaker IA.
# États de l'emploi
Lorsque vous soumettez une tâche à une file d'attente de AWS Batch tâches, la tâche entre dans l'`SUBMITTED`état. Il passe ensuite par les états suivants jusqu'à ce qu'il fonctionne (sortie avec le code `0`) ou échoue (sortie avec un autre code que zéro). Les tâches AWS Batch peuvent présenter les états suivants :
`SUBMITTED`
Une tâche soumise à la file d'attente et qui n'a pas encore été évaluée par le planificateur. Le planificateur évalue la tâche pour déterminer si elle présente des dépendances en attente sur la réussite de l'exécution de toutes les autres tâches. Si des dépendances sont présentes, la tâche est déplacée vers `PENDING`. Si aucune dépendance n'est présente, la tâche est déplacée vers `RUNNABLE`.
`PENDING`
Une tâche qui se trouve dans la file d'attente et qui n'est pas encore en mesure de s'exécuter en raison d'une dépendance à l'égard d'une autre tâche ou d'une autre ressource. Une fois les dépendances satisfaites, la tâche est déplacée vers `RUNNABLE`.
Les parents des tâches matricielles sont informés `PENDING` lorsqu'une tâche enfant est mise à jour `RUNNABLE` et conservent `PENDING` leur statut pendant l'exécution des tâches enfants. Pour consulter ces emplois, filtrez par `PENDING` statut jusqu'à ce que tous les emplois secondaires atteignent l'état terminal.
`RUNNABLE`
Une tâche qui se trouve dans la file d'attente, n'a pas de dépendances en attente, et est donc prête pour la planification sur un hôte. Les tâches dans cet état sont démarrées dès que des ressources suffisantes sont disponibles dans l'un des environnements informatiques mappés à la file d'attente des tâches. Cependant, elles peuvent rester dans cet état indéfiniment lorsque les ressources suffisantes sont indisponibles.
Si vos tâches ne progressent pas vers`STARTING`, consultez la section [Offres d'emploi bloquées dans un `RUNNABLE` statut](job_stuck_in_runnable.md) de résolution des problèmes.
`STARTING`
Ces tâches ont été planifiées pour un hôte et les opérations de lancement de conteneurs correspondantes sont en cours. Une fois l'image de conteneur extraite et le conteneur lancé, la tâche prend l'état `RUNNING`.
La durée d'extraction de l'image, la durée d'exécution d'Amazon EKS InitContainer et la durée de résolution d'Amazon ECS ContainerDependency se produisent à l'état STARTING. Le temps nécessaire à l'extraction d'une image pour votre tâche est équivalent à la durée pendant laquelle votre tâche sera à l'état de départ.
Par exemple, s'il faut trois minutes pour extraire l'image correspondant à votre tâche, celle-ci restera à l'état de démarrage pendant trois minutes. Si l'exécution d'InitContainers prend au total dix minutes, votre tâche Amazon EKS sera démarrée pendant dix minutes. Si votre tâche Amazon ECS ContainerDependencies est définie, celle-ci sera en cours de démarrage jusqu'à ce que toutes les dépendances des conteneurs (leur temps d'exécution) soient résolues. Le démarrage n'est pas inclus dans les délais ; la durée commence à courir. Pour plus d'informations, consultez la section [États des tâches](https://docs.aws.amazon.com/batch/latest/userguide/job_states.html).
`RUNNING`
La tâche s'exécute en tant que tâche de conteneur sur une instance de conteneur Amazon ECS au sein d'un environnement informatique. Lorsque le conteneur de tâche se ferme, le code de sortie du processus détermine si la tâche a réussi ou échoué. Un code de sortie `0` indique la réussite et tout code de sortie autre que zéro indique qu'il s'agit d'un échec. Si la tâche associée à une tentative échouée présente des tentatives restantes dans sa configuration de stratégie de nouvelle tentative facultative, la tâche est déplacée de nouveau vers `RUNNABLE`. Pour de plus amples informations, veuillez consulter [Nouvelles tentatives de travail automatisées](job_retries.md).
Les journaux des `RUNNING` tâches sont disponibles dans CloudWatch Logs. Le groupe de journaux est`/aws/batch/job`, et le format du nom du flux de journaux est le suivant :`first200CharsOfJobDefinitionName/default/ecs_task_id`. Ce format est susceptible de changer dans le futur.
Une fois qu'une tâche a atteint le `RUNNING` statut, vous pouvez récupérer par programmation le nom de son flux de journal à l'aide de l'opération d'[DescribeJobs](https://docs.aws.amazon.com/batch/latest/APIReference/API_DescribeJobs.html)API. Pour plus d'informations, consultez la section [Afficher les données de journal envoyées aux CloudWatch journaux](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#ViewingLogData) dans le *guide de l'utilisateur Amazon CloudWatch Logs*. Par défaut, ces journaux n'expirent jamais. Vous pouvez toutefois modifier la durée de conservation. Pour plus d'informations, consultez la section [Conservation des données du journal des modifications dans CloudWatch les journaux](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/SettingLogRetention.html) du *guide de l'utilisateur Amazon CloudWatch Logs*.
`SUCCEEDED`
La tâche a réussi avec un code de sortie de `0`. L'état des `SUCCEEDED` offres d'emploi est conservé AWS Batch pendant au moins 7 jours.
Les journaux des `SUCCEEDED` tâches sont disponibles dans CloudWatch Logs. Le groupe de journaux est`/aws/batch/job`, et le format du nom du flux de journaux est le suivant :`first200CharsOfJobDefinitionName/default/ecs_task_id`. Ce format est susceptible de changer dans le futur.
Une fois qu'une tâche a atteint le `RUNNING` statut, vous pouvez récupérer par programmation le nom de son flux de journal à l'aide de l'opération d'[DescribeJobs](https://docs.aws.amazon.com/batch/latest/APIReference/API_DescribeJobs.html)API. Pour plus d'informations, consultez la section [Afficher les données de journal envoyées aux CloudWatch journaux](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#ViewingLogData) dans le *guide de l'utilisateur Amazon CloudWatch Logs*. Par défaut, ces journaux n'expirent jamais. Vous pouvez toutefois modifier la durée de conservation. Pour plus d'informations, consultez la section [Conservation des données du journal des modifications dans CloudWatch les journaux](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/SettingLogRetention.html) du *guide de l'utilisateur Amazon CloudWatch Logs*.
`FAILED`
La tâche a échoué dans toutes les tentatives disponibles. L'état des `FAILED` offres d'emploi est conservé AWS Batch pendant au moins 7 jours.
Les journaux des `FAILED` tâches sont disponibles dans CloudWatch Logs. Le groupe de journaux est`/aws/batch/job`, et le format du nom du flux de journaux est le suivant :`first200CharsOfJobDefinitionName/default/ecs_task_id`. Ce format est susceptible de changer dans le futur.
Une fois qu'une tâche a atteint le `RUNNING` statut, vous pouvez récupérer son flux de journal par programmation à l'aide de l'opération [DescribeJobs](https://docs.aws.amazon.com/batch/latest/APIReference/API_DescribeJobs.html)API. Pour plus d'informations, consultez la section [Afficher les données de journal envoyées aux CloudWatch journaux](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#ViewingLogData) dans le *guide de l'utilisateur Amazon CloudWatch Logs*. Par défaut, ces journaux n'expirent jamais. Vous pouvez toutefois modifier la durée de conservation. Pour plus d'informations, consultez la section [Conservation des données du journal des modifications dans CloudWatch les journaux](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/SettingLogRetention.html) du *guide de l'utilisateur Amazon CloudWatch Logs*.
# AWS Batch variables d'environnement de travail
AWS Batch définit des variables d'environnement spécifiques dans les tâches de conteneur. Ces variables d'environnement fournissent une introspection pour les conteneurs contenus dans les tâches. Vous pouvez utiliser les valeurs de ces variables dans la logique de vos applications. Toutes les variables AWS Batch définies commencent par le `AWS_BATCH_` préfixe. Il s'agit d'un préfixe de variable d'environnement protégé. Vous ne pouvez pas utiliser ce préfixe pour vos propres variables dans les définitions de tâches ou les remplacements.
Les variables d'environnement suivantes sont disponibles dans les conteneurs de tâche :
`AWS_BATCH_CE_NAME`
Cette variable est définie sur le nom de l'environnement informatique dans lequel votre tâche est placée.
`AWS_BATCH_JOB_ARRAY_INDEX`
Cette variable est uniquement définie dans les tâches de tableau enfants. L'index de tâche de tableau commence à 0. Chaque tâche enfant reçoit un numéro d'index unique. Par exemple, une tâche de tableau avec 10 enfants a les valeurs d'index de 0 à 9. Vous pouvez utiliser cette valeur d'index pour contrôler la façon dont les enfants de votre tâche de tableau sont différenciés. Pour de plus amples informations, veuillez consulter [Utilisez l'index des tâches matriciel pour contrôler la différenciation des tâches](array_index_example.md).
`AWS_BATCH_JOB_ARRAY_SIZE`
Cette variable est définie sur la taille de la tâche de tableau parent. La taille de la tâche de matrice parent est transmise à la tâche de matrice enfant dans cette variable.
`AWS_BATCH_JOB_ATTEMPT`
Cette variable est définie sur le numéro de tentative de tâche. La première tentative est numérotée 1. Pour de plus amples informations, veuillez consulter [Nouvelles tentatives de travail automatisées](job_retries.md).
`AWS_BATCH_JOB_ID`
Cette variable est définie sur l'ID de la AWS Batch tâche.
`AWS_BATCH_JOB_KUBERNETES_NODE_UID`
Cette variable est définie comme l'KubernetesUID de l'objet nœud qui se trouve dans le cluster Kubernetes sur lequel le pod s'exécute. Cette variable n'est définie que pour les tâches exécutées sur les ressources Amazon EKS. Pour plus d'informations, consultez [UIDs](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids)la *Kubernetesdocumentation*.
`AWS_BATCH_JOB_MAIN_NODE_INDEX`
Cette variable est uniquement définie dans les tâches parallèles à plusieurs nœuds. Cette variable est définie sur le numéro d'index du nœud principal de la tâche. Le code de votre application peut le comparer `AWS_BATCH_JOB_MAIN_NODE_INDEX` à `AWS_BATCH_JOB_NODE_INDEX` celui d'un nœud individuel pour déterminer s'il s'agit du nœud principal.
`AWS_BATCH_JOB_MAIN_NODE_PRIVATE_IPV4_ADDRESS`
Cette variable n'est définie que dans les nœuds enfants de tâches parallèles à nœuds multiples. Cette variable n'est pas présente sur le nœud principal, mais elle est définie sur l' IPv4 adresse privée du nœud principal de la tâche. Votre code d'application du nœud enfant peut utiliser cette adresse pour communiquer avec le nœud principal.
`AWS_BATCH_JOB_NODE_INDEX`
Cette variable est uniquement définie dans les tâches parallèles à plusieurs nœuds. Cette variable est définie sur le numéro d'index du nœud du nœud. L'index du nœud commence à 0 et chaque nœud reçoit un numéro d'index unique. Par exemple, une tâche parallèle à plusieurs nœuds avec 10 enfants dispose de valeurs d'index de 0 à 9.
`AWS_BATCH_JOB_NUM_NODES`
Cette variable est uniquement définie dans les tâches parallèles à plusieurs nœuds. Cette variable est définie sur le nombre de nœuds que vous avez demandés pour votre tâche parallèle à nœuds multiples.
`AWS_BATCH_JQ_NAME`
Cette variable est définie sur le nom de la file d'attente pour laquelle votre tâche a été soumise.
# Nouvelles tentatives de travail automatisées
Vous pouvez appliquer une stratégie de nouvelle tentative à vos tâches et définitions de tâches qui permet à vos tâches d'être automatiquement retentées si elles échouent. Les scénarios de défaillance possibles sont les suivants :
+ Tout code de sortie autre que zéro à partir d'un conteneur de tâche
+ Défaillance ou arrêt de l'instance Amazon EC2
+ Erreur ou panne de AWS service interne
Lorsqu'une tâche est soumise à une file d'attente de tâches et placée dans l'`RUNNING`état considéré comme une tentative. Par défaut, chaque tâche a une tentative de passer à l'état `SUCCEEDED` ou `FAILED`. Cependant, les flux de travail de définition et de soumission des tâches peuvent être utilisés pour spécifier une stratégie de nouvelle tentative comprenant entre 1 et 10 tentatives. S'il [evaluateOnExit](job_definition_parameters.md#retryStrategy-evaluateOnExit)est spécifié, il peut contenir jusqu'à 5 stratégies de nouvelle tentative. Si cette [evaluateOnExit](https://docs.aws.amazon.com/batch/latest/APIReference/API_EvaluateOnExit.html)option est spécifiée, mais qu'aucune des stratégies de nouvelle tentative ne correspond, la tâche est réessayée. Pour les tâches qui ne correspondent pas à la sortie, ajoutez une entrée finale qui se ferme pour une raison ou une autre. Par exemple, cet `evaluateOnExit` objet possède deux entrées contenant des actions de `RETRY` et une entrée finale contenant une action de`EXIT`.
```
"evaluateOnExit": [
{
"action": "RETRY",
"onReason": "AGENT"
},
{
"action": "RETRY",
"onStatusReason": "Task failed to start"
},
{
"action": "EXIT",
"onReason": "*"
}
]
```
Lors de l'exécution, la variable d'environnement `AWS_BATCH_JOB_ATTEMPT` est définie sur le numéro de tentative de tâche correspondant du conteneur. La première tentative est numérotée `1` et les tentatives suivantes sont classées par ordre croissant (par exemple, 2, 3, 4).
Supposons, par exemple, qu'une tentative de travail échoue pour une raison quelconque et que le nombre de tentatives spécifié dans la configuration des nouvelles tentatives soit supérieur à ce `AWS_BATCH_JOB_ATTEMPT` nombre. Ensuite, la tâche est replacée dans son `RUNNABLE` état actuel. Pour de plus amples informations, veuillez consulter [États de l'emploi](job_states.md).
**Note**
Les tâches annulées ou résiliées ne sont pas réessayées. De même, les tâches qui échouent en raison d'une définition de tâche non valide ne sont pas réessayées.
Pour plus d'informations, reportez-vous aux [Stratégie de nouvelle tentative](job_definition_parameters.md#retryStrategy) sections[Création d'une définition de tâche à nœud unique](create-job-definition.md), [Tutoriel : soumettre une offre d'emploi](submit_job.md) et [Codes d'erreur des tâches arrêtées](https://docs.aws.amazon.com/AmazonECS/latest/userguide/stopped-task-error-codes.html).
# Dépendances professionnelles
Lorsque vous soumettez une AWS Batch tâche, vous pouvez spécifier la tâche IDs dont elle dépend. Dans ce cas, le AWS Batch planificateur veille à ce que votre tâche ne soit exécutée qu'une fois les dépendances spécifiées terminées avec succès. Une fois effectuée, la tâche dépendante passe de `PENDING` à `RUNNABLE` puis `STARTING` et `RUNNING`. Si l'une des dépendances de tâche échoue, la tâche dépendante passera automatiquement de `PENDING` à `FAILED`.
Par exemple, une Tâche A peut exprimer une dépendance à plus de 20 autres tâches devant être effectuées avant qu'elle ne puisse s'exécuter. Vous pouvez ensuite envoyer des tâches supplémentaires qui dépendent de la Tâche A et jusqu'à 19 autres tâches.
Pour les tâches de tableau, vous pouvez spécifier un type de dépendance `SEQUENTIAL` sans spécifier d'ID de tâche, afin que chaque tâche de tableau enfant se termine de façon séquentielle à partir de l'index 0. Vous pouvez également spécifier une dépendance de type `N_TO_N` avec un ID de tâche Ainsi, chaque enfant de l'index de cette tâche doive attendre que l'enfant de l'index correspondant de chaque dépendance soit terminé avant de pouvoir commencer. Pour de plus amples informations, veuillez consulter [Tâches liées à](array_jobs.md).
Pour soumettre une AWS Batch tâche comportant des dépendances, consultez[Tutoriel : soumettre une offre d'emploi](submit_job.md).
[Planification axée sur les ressources](resource-aware-scheduling.md)vous permet de planifier des tâches en fonction des ressources consommables nécessaires à leur exécution. Vous spécifiez les ressources consommables nécessaires à l'exécution d'une tâche, et Batch prend en compte ces dépendances de ressources lorsqu'il planifie une tâche. Vous pouvez réduire la sous-utilisation des ressources de calcul en n'allouant que les tâches qui disposent de toutes les ressources nécessaires. La planification basée sur les ressources est disponible pour les politiques de planification FIFO et fair-share et peut être utilisée avec toutes les plateformes de calcul prises en charge par Batch, notamment EKS, ECS et Fargate. Il peut être utilisé avec des tâches Array, des tâches MNP (Multi-Node parallel) et avec des tâches Batch classiques.
# Expiration des délais d'exécution des tâches
Vous pouvez configurer un délai d'expiration pour vos tâches de sorte que si une tâche s'exécute plus longtemps que ce délai, AWS Batch arrête la tâche. Par exemple, vous pouvez avoir une tâche dont vous savez qu'elle ne devrait prendre que 15 minutes. Parfois, votre application est bloquée dans une boucle et s'exécute indéfiniment. Ainsi, vous pouvez définir un délai d'expiration de 30 minutes pour mettre fin à la tâche bloquée.
**Important**
Par défaut, il AWS Batch n'y a pas de délai d'expiration de la tâche. Si vous ne définissez pas de délai d'expiration de la tâche, celle-ci s'exécute jusqu'à ce que le conteneur sorte.
Vous spécifiez un paramètre `attemptDurationSeconds` qui doit être au moins égal à 60 secondes, que ce soit dans votre définition de tâche ou lorsque vous soumettez la tâche. Lorsque ce nombre de secondes s'est écoulé après l'`startedAt`horodatage de la tentative de tâche, AWS Batch met fin à la tâche. Sur la ressource de calcul, le conteneur de tâches reçoit un signal `SIGTERM` pour donner à votre application la possibilité de se fermer de façon appropriée. Si le conteneur est encore en cours d'exécution après 30 secondes, un signal `SIGKILL` est envoyé pour forcer la fermeture du conteneur.
Les arrêts dus à des délais d'expiration sont traités au mieux Vous ne devez pas vous attendre à ce que votre délai d'expiration expire exactement au moment où la tentative de travail arrive à expiration (cela peut prendre quelques secondes de plus). Si votre application a besoin d'une exécution de délai d'expiration précise, vous devez implémenter cette logique au sein de l'application. Si un grand nombre de tâches arrivent à expiration simultanément, les arrêts dus à des délais d'expiration sont traités comme une file d'attente premier entré, premier sorti, où les tâches sont arrêtées par lots.
**Note**
Il n'y a pas de délai d'expiration maximal pour une AWS Batch tâche.
Si une tâche est interrompue pour avoir dépassé le délai imparti, elle n'est pas réessayée. Si une tentative de tâche échoue toute seule, elle peut être relancée si les nouvelles tentatives sont activées, et le décompte du délai d'expiration repart à zéro pour la nouvelle tentative.
**Important**
Les tâches exécutées sur les ressources Fargate ne peuvent pas s'attendre à être exécutées pendant plus de 14 jours. Si la durée du délai d'attente dépasse 14 jours, les ressources de Fargate risquent de ne plus être disponibles et le travail sera interrompu.
Pour les tâches de tableau, les tâches enfants ont la même configuration de délai d'expiration que la tâche parente.
Pour plus d'informations sur la soumission d'une AWS Batch tâche avec une configuration de délai d'expiration, consultez[Tutoriel : soumettre une offre d'emploi](submit_job.md).
# Offres d'emploi Amazon EKS
Un travail est la plus petite unité de travail dans laquelle il s'agit AWS Batch. Une AWS Batch tâche sur Amazon EKS est one-to-one mappée vers un Kubernetes pod. Une définition de AWS Batch tâche est un modèle de AWS Batch tâche. Lorsque vous soumettez une AWS Batch tâche, vous faites référence à une définition de tâche, vous ciblez une file d'attente de tâches et vous donnez un nom à une tâche. Dans la définition d'une AWS Batch tâche sur Amazon EKS, le paramètre [EKSProperties](https://docs.aws.amazon.com/batch/latest/APIReference/API_EksProperties.html) définit l'ensemble de paramètres pris en charge par une tâche AWS Batch sur Amazon EKS. Dans une [SubmitJob](https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitJob.html)demande, le [eksPropertiesOverride](https://docs.aws.amazon.com/batch/latest/APIReference/API_EksPropertiesOverride.html)paramètre permet de remplacer certains paramètres courants. Ainsi, vous pouvez utiliser des modèles de définitions de tâches pour plusieurs tâches. Lorsqu'une tâche est envoyée à votre cluster Amazon EKS, AWS Batch elle est transformée en tâche `podspec` (`Kind: Pod`). `podspec`utilise des AWS Batch paramètres supplémentaires pour garantir que les tâches sont correctement dimensionnées et planifiées. AWS Batch combine des étiquettes et des nuances pour garantir que les tâches ne s'exécutent que sur les nœuds AWS Batch gérés et que les autres pods ne s'exécutent pas sur ces nœuds.
**Important**
Si le `hostNetwork` paramètre n'est pas défini explicitement dans une définition de tâche Amazon EKS, le mode réseau du pod est AWS Batch défini par défaut sur le mode hôte. Plus précisément, les paramètres suivants sont appliqués : `hostNetwork=true` et`dnsPolicy=ClusterFirstWithHostNet`.
AWS Batch nettoie les modules de travail peu après qu'un module ait terminé sa tâche. Pour consulter les journaux des applications pod, configurez un service de journalisation pour votre cluster. Pour de plus amples informations, veuillez consulter [Utiliser CloudWatch les journaux pour surveiller AWS Batch les tâches Amazon EKS](batch-eks-cloudwatch-logs.md).
**Topics**
+ [Tutoriel : mapper une tâche en cours d'exécution à un pod et à un nœud](eks-jobs-map-running-job.md)
+ [Tutoriel : associer un module en cours d'exécution à sa tâche](eks-jobs-map-running-pod-to-job.md)
# Tutoriel : mapper une tâche en cours d'exécution à un pod et à un nœud
Les `nodeName` paramètres `podProperties` d'une tâche en cours d'exécution ont été `podName` définis pour la tentative de tâche en cours. Utilisez l'opération [DescribeJobs](https://docs.aws.amazon.com/batch/latest/APIReference/API_DescribeJobs.html)API pour afficher ces paramètres.
Voici un exemple de sortie.
```
$ aws batch describe-jobs --job 2d044787-c663-4ce6-a6fe-f2baf7e51b04
{
"jobs": [
{
"status": "RUNNING",
"jobArn": "arn:aws:batch:us-east-1:123456789012:job/2d044787-c663-4ce6-a6fe-f2baf7e51b04",
"jobDefinition": "arn:aws:batch:us-east-1:123456789012:job-definition/MyJobOnEks_SleepWithRequestsOnly:1",
"jobQueue": "arn:aws:batch:us-east-1:123456789012:job-queue/My-Eks-JQ1",
"jobId": "2d044787-c663-4ce6-a6fe-f2baf7e51b04",
"eksProperties": {
"podProperties": {
"nodeName": "ip-192-168-55-175.ec2.internal",
"containers": [
{
"image": "public.ecr.aws/amazonlinux/amazonlinux:2",
"resources": {
"requests": {
"cpu": "1",
"memory": "1024Mi"
}
}
}
],
"podName": "aws-batch.b0aca953-ba8f-3791-83e2-ed13af39428c"
}
}
}
]
}
```
Pour une tâche pour laquelle les nouvelles tentatives sont activées, la `podName` fin `nodeName` de chaque tentative terminée figure dans le paramètre de `eksAttempts` liste de l'opération d'[DescribeJobs](https://docs.aws.amazon.com/batch/latest/APIReference/API_DescribeJobs.html)API. La `podName` fin `nodeName` de la tentative d'exécution en cours se trouve dans l'`podProperties`objet.
# Tutoriel : associer un module en cours d'exécution à sa tâche
Un pod possède des étiquettes qui indiquent le `jobId` et `uuid` de l'environnement informatique auquel il appartient. AWS Batch injecte des variables d'environnement afin que l'exécution de la tâche puisse référencer les informations de la tâche. Pour de plus amples informations, veuillez consulter [AWS Batch variables d'environnement de travail](job_env_vars.md). Vous pouvez consulter ces informations en exécutant la commande suivante. La sortie est la suivante.
```
$ kubectl describe pod aws-batch.14638eb9-d218-372d-ba5c-1c9ab9c7f2a1 -n my-aws-batch-namespace
Name: aws-batch.14638eb9-d218-372d-ba5c-1c9ab9c7f2a1
Namespace: my-aws-batch-namespace
Priority: 0
Node: ip-192-168-45-88.ec2.internal/192.168.45.88
Start Time: Wed, 26 Oct 2022 00:30:48 +0000
Labels: batch.amazonaws.com/compute-environment-uuid=5c19160b-d450-31c9-8454-86cf5b30548f
batch.amazonaws.com/job-id=f980f2cf-6309-4c77-a2b2-d83fbba0e9f0
batch.amazonaws.com/node-uid=a4be5c1d-9881-4524-b967-587789094647
...
Status: Running
IP: 192.168.45.88
IPs:
IP: 192.168.45.88
Containers:
default:
Image: public.ecr.aws/amazonlinux/amazonlinux:2
...
Environment:
AWS_BATCH_JOB_KUBERNETES_NODE_UID: a4be5c1d-9881-4524-b967-587789094647
AWS_BATCH_JOB_ID: f980f2cf-6309-4c77-a2b2-d83fbba0e9f0
AWS_BATCH_JQ_NAME: My-Eks-JQ1
AWS_BATCH_JOB_ATTEMPT: 1
AWS_BATCH_CE_NAME: My-Eks-CE1
...
```
**Fonctionnalités prises en charge par AWS Batch Amazon EKS Jobs**
Voici les fonctionnalités AWS Batch spécifiques qui sont également communes aux Kubernetes tâches exécutées sur Amazon EKS :
+ [Dépendances professionnelles](job_dependencies.md)
+ [Tâches liées à](array_jobs.md)
+ [Expiration des délais d'exécution des tâches](job_timeouts.md)
+ [Nouvelles tentatives de travail automatisées](job_retries.md)
+ [Utilisez la planification équitable pour faciliter la planification des tâches](fair-share-scheduling.md)
**Kubernetes et `Secrets` `ServiceAccounts`**
AWS Batch prend en charge le référencement Kubernetes `Secrets` et. `ServiceAccounts` Vous pouvez configurer des pods pour utiliser les rôles IAM Amazon EKS pour les comptes de service. Pour plus d'informations, consultez [la section Configuration des pods pour utiliser un compte Kubernetes de service](https://docs.aws.amazon.com/eks/latest/userguide/pod-configuration.html) dans le [https://docs.aws.amazon.com/eks/latest/userguide/](https://docs.aws.amazon.com/eks/latest/userguide/).
**Documents connexes**
+ [Considérations relatives à la mémoire et au vCPU pour AWS Batch Amazon EKS](memory-cpu-batch-eks.md)
+ [Exécuter des tâches GPU](gpu-jobs.md)
+ [Offres d'emploi bloquées dans un `RUNNABLE` statut](job_stuck_in_runnable.md)
# Tâches parallèles sur plusieurs nœuds
Vous pouvez utiliser des tâches parallèles à nœuds multiples pour exécuter des tâches uniques couvrant plusieurs instances Amazon EC2. Avec les tâches parallèles à AWS Batch nœuds multiples (également appelées *planification en groupe*), vous pouvez exécuter des applications informatiques hautes performances à grande échelle et un entraînement de modèles de GPU distribués sans avoir à lancer, configurer et gérer directement les ressources Amazon EC2. Une tâche parallèle à AWS Batch nœuds multiples est compatible avec n'importe quel framework prenant en charge la communication inter-nœuds basée sur l'IP. Les exemples incluent Apache MXNet TensorFlow, Caffe2 ou MPI (Message Passing Interface).
Les tâches parallèles à nœuds multiples sont soumises en tant que tâche unique. Toutefois, votre définition de tâche (ou les remplacements de nœud de soumission de tâche) spécifie le nombre de nœuds à créer pour la tâche et les groupes de nœuds à créer. Chaque tâche parallèle à plusieurs nœuds contient un **nœud principal** qui est lancé en premier. Une fois le nœud principal activé, les nœuds enfants sont lancés et démarrés. La tâche n'est terminée que si le nœud principal sort. Tous les nœuds enfants sont ensuite arrêtés. Pour de plus amples informations, veuillez consulter [Groupes de nœuds](mnp-node-groups.md).
Les nœuds de tâches parallèles à nœuds multiples sont à locataire unique. Cela signifie qu'un seul conteneur de tâches est exécuté sur chaque instance Amazon EC2.
Le statut de la tâche finale (`SUCCEEDED` ou `FAILED`) est déterminé par le statut de la tâche finale du nœud principal. Pour connaître le statut d'une tâche parallèle à nœuds multiples, décrivez la tâche à l'aide de l'ID de tâche qui a été renvoyé lorsque vous l'avez soumise. Si vous avez besoin des informations relatives aux nœuds enfants, décrivez chaque nœud enfant individuellement. Vous pouvez adresser les nœuds à l'aide de la `#N` notation (en commençant par 0). Par exemple, pour accéder aux détails du deuxième nœud d'une tâche, décrivez *aws\$1batch\$1job\$1id* \$11 à l'aide de l'opération AWS Batch [DescribeJobs](https://docs.aws.amazon.com/batch/latest/APIReference/API_DescribeJobs.html)API. Les informations `started`, `stoppedAt`, `statusReason` et `exit` concernant une tâche en parallèle à plusieurs nœuds sont renseignées à partir du nœud principal.
Si vous spécifiez des nouvelles tentatives de travail, une défaillance du nœud principal entraîne une nouvelle tentative. Les défaillances du nœud enfant n'entraînent pas d'autres tentatives. Chaque nouvelle tentative d'une tâche parallèle à plusieurs nœuds met à jour la tentative correspondante de ses nœuds enfants associés.
Pour exécuter des tâches parallèles sur plusieurs nœuds AWS Batch, le code de votre application doit contenir les frameworks et les bibliothèques nécessaires à la communication distribuée.
**Topics**
+ [Variables d’environnement](mnp-env-vars.md)
+ [Groupes de nœuds](mnp-node-groups.md)
+ [Cycle de vie des tâches pour les tâches MNP](job-lifecycle.md)
+ [Considérations relatives à l'environnement informatique pour MNP avec AWS Batch](mnp-ce.md)
# Variables d’environnement
Au moment de l'exécution, chaque nœud est configuré avec les variables d'environnement standard que toutes les AWS Batch tâches reçoivent. En outre, les nœuds sont configurés avec les variables d'environnement suivantes, spécifiques aux tâches parallèles à nœuds multiples :
`AWS_BATCH_JOB_MAIN_NODE_INDEX`
Cette variable est définie sur le numéro d'index du nœud principal de la tâche. Le code de votre application peut le comparer `AWS_BATCH_JOB_MAIN_NODE_INDEX` à `AWS_BATCH_JOB_NODE_INDEX` celui d'un nœud individuel pour déterminer s'il s'agit du nœud principal.
`AWS_BATCH_JOB_MAIN_NODE_PRIVATE_IPV4_ADDRESS`
Cette variable n'est définie que dans les nœuds enfants de tâches parallèles à nœuds multiples. Cette variable n'est pas présente sur le nœud principal. Cette variable est définie sur l' IPv4 adresse privée du nœud principal de la tâche. Votre code d'application du nœud enfant peut utiliser cette adresse pour communiquer avec le nœud principal.
`AWS_BATCH_JOB_NODE_INDEX`
Cette variable est définie sur le numéro d'index du nœud du nœud. L'index du nœud commence à 0 et chaque nœud reçoit un numéro d'index unique. Par exemple, une tâche parallèle à plusieurs nœuds avec 10 enfants dispose de valeurs d'index de 0 à 9.
`AWS_BATCH_JOB_NUM_NODES`
Cette variable est définie sur le nombre de nœuds que vous avez demandés pour votre tâche parallèle à plusieurs nœuds.
# Groupes de nœuds
Un groupe de nœuds est un groupe identique de nœuds de travail qui partagent tous les mêmes propriétés de conteneur. Vous pouvez spécifier jusqu' AWS Batch à cinq groupes de nœuds distincts pour chaque tâche.
Chaque groupe peut avoir ses propres images de conteneur, commandes, variables d'environnement, etc. Par exemple, vous pouvez soumettre une tâche qui nécessite une seule `c5.xlarge` instance pour le nœud principal et cinq nœuds enfants d'`c5.xlarge`instance. Chacun de ces groupes de nœuds distincts peut spécifier des images de conteneur ou des commandes différentes à exécuter pour chaque tâche.
Sinon, tous les nœuds de votre tâche peuvent utiliser un seul groupe de nœuds. De plus, le code de votre application peut différencier les rôles des nœuds tels que le nœud principal et le nœud enfant. Pour ce faire, il compare la variable d'`AWS_BATCH_JOB_MAIN_NODE_INDEX`environnement à sa propre valeur pour`AWS_BATCH_JOB_NODE_INDEX`. Vous pouvez avoir jusqu'à 1 000 nœuds par tâche. Il s'agit de la limite par défaut pour les instances d'un cluster Amazon ECS. Vous pouvez [demander à augmenter cette limite](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html).
**Note**
Actuellement, tous les groupes de nœuds d'une tâche parallèle à nœuds multiples doivent utiliser le même type d'instance.
# Cycle de vie des tâches pour les tâches MNP
Lorsque vous soumettez une tâche parallèle à nœuds multiples, la tâche entre dans le `SUBMITTED` statut. Ensuite, le travail attend la fin de toutes les dépendances du travail. La tâche passe également au `RUNNABLE` statut. Enfin, AWS Batch fournit la capacité d'instance requise pour exécuter votre tâche et lance ces instances.
Chaque tâche parallèle à plusieurs nœuds contient un **nœud principal**. Le nœud principal est une sous-tâche unique qui AWS Batch surveille afin de déterminer le résultat de la tâche multi-nœuds soumise. Le nœud principal est lancé en premier et il passe au statut `STARTING`. La valeur du délai d'attente spécifiée dans le `attemptDurationSeconds` paramètre s'applique à l'ensemble de la tâche et non aux nœuds.
Lorsque le nœud principal atteint le `RUNNING` statut après l'exécution du conteneur du nœud, les nœuds enfants sont lancés et passent également au `STARTING` statut. Les nœuds enfants s'affichent dans un ordre aléatoire. Il n'existe aucune garantie sur la planification ou l'ordre de lancement des nœuds enfants. Pour garantir que tous les nœuds des tâches sont dans le même `RUNNING` état après l'exécution du conteneur du nœud, le code de votre application peut interroger l' AWS Batch API pour obtenir des informations sur le nœud principal et le nœud enfant. Le code de l'application peut également attendre que tous les nœuds soient en ligne avant de démarrer une tâche de traitement distribué. L'adresse IP privée du nœud principal est disponible en tant que variable d'environnement `AWS_BATCH_JOB_MAIN_NODE_PRIVATE_IPV4_ADDRESS` dans chaque nœud enfant. Votre code d'application peut utiliser ces informations pour se coordonner et communiquer les données entre chaque tâche.
À mesure que les nœuds individuels se terminent, ils se déplacent vers `SUCCEEDED` ou `FAILED` selon leur code de sortie. Si le nœud principal se termine, la tâche est considérée comme terminée et tous les nœuds enfants sont arrêtés. Si un nœud enfant meurt, aucune action AWS Batch n'est entreprise sur les autres nœuds de la tâche. Si vous ne souhaitez pas que votre travail se poursuive avec un nombre réduit de nœuds, vous devez en tenir compte dans le code de votre application. Cela met fin à la tâche ou l'annule.
# Considérations relatives à l'environnement informatique pour MNP avec AWS Batch
Plusieurs points sont à prendre en compte lors de la configuration des environnements de calcul pour exécuter des tâches parallèles à plusieurs nœuds avec AWS Batch.
+ Les tâches parallèles à nœuds multiples ne sont pas prises en charge dans les environnements `UNMANAGED` informatiques.
+ Si vous souhaitez soumettre des tâches parallèles à nœuds multiples à un environnement informatique, créez un groupe de placement de *clusters* dans une seule zone de disponibilité et associez-le à vos ressources de calcul. Cela permet de maintenir vos tâches parallèles à plusieurs nœuds sur un groupe logique d'instances à proximité avec un potentiel de flux réseau élevé. Pour plus d'informations, veuillez consulter la rubrique [Groupes de placement](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html) dans le *Guide de l'utilisateur Amazon EC2*.
+ Les tâches parallèles à nœuds multiples ne sont pas prises en charge dans les environnements informatiques qui utilisent des instances Spot.
+ AWS Batch les tâches parallèles à nœuds multiples utilisent le mode `awsvpc` réseau Amazon ECS, qui confère à vos conteneurs de tâches parallèles à nœuds multiples les mêmes propriétés réseau que les instances Amazon EC2. Chaque conteneur de tâche parallèle à plusieurs nœuds obtient sa propre interface réseau Elastic, une adresse IP privée principale et un nom d'hôte DNS interne. L'interface réseau est créée dans le même sous-réseau VPC que sa ressource de calcul hôte.
+ Votre environnement informatique ne peut pas être associé à plus de cinq groupes de sécurité. Les interfaces réseau élastiques créées et associées à une tâche MNP utiliseront les groupes de sécurité spécifiés dans votre environnement informatique. Si vous ne spécifiez aucun groupe de sécurité, le groupe de sécurité par défaut du VPC est utilisé.
+ Le mode `awsvpc` réseau ne fournit pas les interfaces réseau élastiques pour les tâches parallèles à nœuds multiples avec des adresses IP publiques. Pour accéder à Internet, vos ressources de calcul doivent être lancées dans un sous-réseau privé configuré pour utiliser une passerelle NAT. Pour plus d'informations, veuillez consulter [NAT Gateways (Passerelles NAT)](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html) dans le *Guide de l'utilisateur Amazon VPC*. Les communications entre nœuds doivent utiliser l'adresse IP privée ou le nom d'hôte DNS du nœud. Les tâches parallèles à nœuds multiples qui s'exécutent sur des ressources informatiques situées dans des sous-réseaux publics ne disposent pas d'un accès réseau sortant. Pour créer un VPC avec des sous-réseaux privés et une passerelle NAT, consultez [Créer un Virtual Private Cloud](create-public-private-vpc.md).
+ Les interfaces réseau élastiques créées et associées à vos ressources informatiques ne peuvent pas être détachées manuellement ni modifiées par votre compte. Cela permet d'éviter la suppression accidentelle d'une interface Elastic network associée à une tâche en cours d'exécution. Pour libérer les interfaces réseau Elastic pour une tâche, arrêtez-la.
+ Votre environnement informatique doit avoir une valeur maximale de v suffisante CPUs pour prendre en charge votre tâche parallèle sur plusieurs nœuds.
+ Votre quota d'instances Amazon EC2 inclut le nombre d'instances nécessaires pour exécuter votre tâche. Supposons, par exemple, que votre tâche nécessite 30 instances, mais que votre compte ne puisse exécuter que 20 instances dans une région. Ensuite, votre travail restera bloqué dans `RUNNABLE` son statut.
+ Si vous spécifiez un type d'instance pour un groupe de nœuds dans une tâche parallèle à nœuds multiples, votre environnement de calcul doit lancer ce type d'instance.
# Tâches parallèles à nœuds multiples sur Amazon EKS
Vous pouvez utiliser AWS Batch Amazon Elastic Kubernetes Service pour exécuter des tâches multi-nœuds parallèles (MNP) (également *appelées* planification groupée) sur vos clusters gérés. Kubernetes Cette option est couramment utilisée pour les tâches volumineuses, étroitement couplées et à hautes performances qui ne peuvent pas être exécutées sur une seule instance Amazon Elastic Compute Cloud. Pour de plus amples informations, veuillez consulter [Tâches parallèles sur plusieurs nœuds](multi-node-parallel-jobs.md).
Vous pouvez utiliser cette fonctionnalité pour exécuter des applications informatiques hautes performances Kubernetes spécifiques gérées par Amazon EKS, pour la formation de grands modèles linguistiques et pour d'autres tâches d'intelligence artificielle (IA) /apprentissage automatique (ML).
**Topics**
+ [Exécution de tâches MNP](mnp-eks-running-mnp-jobs.md)
+ [Création d'une définition de tâche Amazon EKS MNP](mnp-eks-create-eks-mnp-job-definition.md)
+ [Soumettre une offre d'emploi Amazon EKS MNP](mnp-eks-submit-eks-mnp-job.md)
+ [Remplacer une définition de tâche Amazon EKS MNP](mnp-eks-override-eks-mnp-job-definition.md)
# Exécution de tâches MNP
AWS Batch prend en charge les tâches MNP sur Amazon Elastic Container Service et Amazon EKS à l'aide d'Amazon EC2. Vous trouverez ci-dessous des informations plus détaillées sur les paramètres d'instance et de conteneur de la fonctionnalité.
## Quotas d'instance pour MNP sur Amazon EKS
+ Jusqu'à 1 000 instances peuvent être utilisées pour une seule tâche MNP.
+ Jusqu'à 5 000 instances peuvent rejoindre un seul cluster Amazon EKS.
+ Jusqu'à 5 environnements informatiques peuvent être mis en cluster et attachés à une file d'attente de tâches.
Par exemple, vous pouvez mettre à l'échelle jusqu'à 5 environnements informatiques en cluster dans une file d'attente de tâches et 1 000 instances dans chaque environnement informatique.
Outre les paramètres de l'instance, il est important de noter que vous ne pouvez pas utiliser Fargate pour les tâches MNP par le biais de l'un ou l'autre service.
Vous ne pouvez utiliser qu'un seul type d'instance dans chaque tâche MNP. Vous pouvez modifier le type d'instance en mettant à jour l'environnement de calcul ou lorsque vous définissez un nouvel environnement de calcul. Vous pouvez également spécifier le type d'instance et indiquer les exigences en matière de vCPU et de mémoire lors de la création de la définition de tâche.
## Quotas de conteneurs pour MNP sur Amazon EKS
+ Une tâche parallèle à nœuds multiples prend en charge un pod par nœud.
+ Jusqu'à 10 conteneurs (ou 10 conteneurs init). Pour plus d'informations, consultez [Init Containers](https://kubernetes.io/docs/concepts/workloads/pods/init-containers/) dans la *documentation de Kubernetes*.) dans chaque pod.
+ Jusqu'à 5 plages de nœuds par tâche MNP.
+ Jusqu'à 10 images de conteneur distinctes dans chaque plage de nœuds.
Par exemple, vous pouvez exécuter jusqu'à 10 000 conteneurs dans une seule tâche MNP contenant 5 plages de nœuds et un total de 50 images uniques.
## Exécution de tâches MNP dans un Amazon VPC privé et un cluster Amazon EKS
Les tâches MNP peuvent être exécutées sur n'importe quel cluster Amazon EKS, qu'il dispose d'un accès Internet public ou non. Lorsque vous utilisez un cluster Amazon EKS avec un accès réseau privé uniquement, assurez-vous qu'il AWS Batch peut accéder au plan de contrôle Amazon EKS et au serveur Kubernetes d'API géré. Vous pouvez accorder l'accès nécessaire via les points de terminaison Amazon Virtual Private Cloud. Pour plus d'informations, consultez [Configurer un service de point de terminaison](https://docs.aws.amazon.com/vpc/latest/privatelink/configure-endpoint-service.html).
Les pods du cluster Amazon EKS ne peuvent pas télécharger d'image depuis une source publique car le VPC privé n'a pas accès à Internet. Votre cluster Amazon EKS doit extraire des images d'un registre de conteneurs intégré à votre Amazon VPC. Vous pouvez créer un [Amazon Elastic Container Registry (Amazon ECR) dans votre Amazon](https://docs.aws.amazon.com/AmazonECR/latest/userguide/Registries.html) VPC et y copier des images de conteneur pour que vos nœuds puissent y accéder.
Vous pouvez également créer une règle de cache d'extraction avec Amazon ECR. Une fois qu'une règle de cache d'extraction est créée pour un registre public externe, vous pouvez simplement extraire une image de ce registre public externe à l'aide de l'URI de votre registre privé Amazon ECR. Amazon ECR crée ensuite un référentiel et met l'image en cache. Lorsqu'une image mise en cache est extraite à l'aide de l'URI du registre privé Amazon ECR, Amazon ECR vérifie le registre distant pour voir s'il existe une nouvelle version de l'image et met à jour votre registre privé jusqu'à une fois toutes les 24 heures. Pour plus d'informations, consultez [Création d'une règle de cache d'extraction dans Amazon ECR.](https://docs.aws.amazon.com/AmazonECR/latest/userguide/pull-through-cache-creating-rule.html)
## Notification d'erreur
Si vos offres d'emploi MNP sont bloquées, vous pouvez recevoir des notifications via Amazon AWS Management Console et Amazon EventBridge. Par exemple, si une tâche MNP est bloquée en tête de file d'attente, vous pouvez être averti du problème et recevoir des informations sur sa cause afin que vous puissiez prendre des mesures rapides pour débloquer votre file d'attente de tâches. Vous pouvez éventuellement mettre fin automatiquement à la tâche MNP si aucune action n'est entreprise dans un laps de temps défini dans le modèle de file d'attente des tâches. Pour de plus amples informations, consultez [Événements bloqués dans la file d'offres d'emploi](batch-job-queue-blocked-events.md).
# Création d'une définition de tâche Amazon EKS MNP
Pour définir et exécuter des tâches MNP sur Amazon EKS, de nouveaux paramètres sont intégrés aux opérations [https://docs.aws.amazon.com/batch/latest/APIReference/API_RegisterJobDefinition.html](https://docs.aws.amazon.com/batch/latest/APIReference/API_RegisterJobDefinition.html)et à l'[https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitJob.html](https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitJob.html)API.
+ Utilisez la [https://docs.aws.amazon.com/batch/latest/APIReference/API_EksProperties.html](https://docs.aws.amazon.com/batch/latest/APIReference/API_EksProperties.html)section ci-dessous pour définir votre définition de tâche MNP.
+ À utiliser [https://docs.aws.amazon.com/batch/latest/APIReference/API_EksPropertiesOverride.html](https://docs.aws.amazon.com/batch/latest/APIReference/API_EksPropertiesOverride.html)sous la [https://docs.aws.amazon.com//batch/latest/APIReference/API_NodePropertyOverride.html](https://docs.aws.amazon.com//batch/latest/APIReference/API_NodePropertyOverride.html)section pour remplacer les paramètres définis dans la définition de tâche lors de la soumission d'une tâche MNP.
Ces actions peuvent être définies par le biais d'opérations d'API et du AWS Management Console.
## Référence : Enregistrez la charge utile de la demande de définition de tâche Amazon EKS MNP
L'exemple suivant montre comment enregistrer une définition de tâche Amazon EKS MNP avec deux nœuds.
```
{
"jobDefinitionName": "MyEksMnpJobDefinition",
"type": "multinode",
"nodeProperties": {
"numNodes": 2,
"mainNode": 0,
"nodeRangeProperties": [
{
"targetNodes" : "0:",
"eksProperties": {
"podProperties": {
"containers": [
{
"name": "test-eks-container-1",
"image": "public.ecr.aws/amazonlinux/amazonlinux:2",
"command": [
"sleep",
"60"
],
"resources": {
"limits": {
"cpu": "1",
"memory": "1024Mi"
}
},
"securityContext":{
"runAsUser":1000,
"runAsGroup":3000,
"privileged":true,
"readOnlyRootFilesystem":true,
"runAsNonRoot":true
}
}
],
"initContainers": [
{
"name":"init-ekscontainer",
"image": "public.ecr.aws/amazonlinux/amazonlinux:2",
"command": [
"echo",
"helloWorld"
],
"resources": {
"limits": {
"cpu": "1",
"memory": "1024Mi"
}
}
}
],
"metadata": {
"labels": {
"environment" : "test"
}
}
}
}
}
]
}
}
```
Pour enregistrer la définition de tâche à l'aide de AWS CLI, copiez-la dans un fichier local nommé *MyEksMnpJobDefinition.json* et exécutez la commande suivante.
```
aws batch register-job-definition --cli-input-json file://MyEksMnpJobDefinition.json
```
Vous recevrez la réponse JSON suivante.
```
{
"jobDefinitionName": "MyEksMnpJobDefinition",
"jobDefinitionArn": "arn:aws:batch:us-east-1:0123456789:job-definition/MyEksMnpJobDefinition:1",
"revision": 1
}
```
# Soumettre une offre d'emploi Amazon EKS MNP
Pour soumettre une tâche à l'aide de la définition de tâche enregistrée, entrez la commande suivante. Remplacez la valeur de par le nom ou l'ARN d'une file d'attente de tâches préexistante associée à un environnement informatique Amazon EKS.
```
aws batch submit-job --job-queue \
--job-definition MyEksMnpJobDefinition \
--job-name myFirstEksMnpJob
```
Vous recevrez la réponse JSON suivante.
```
{
"jobArn": "arn:aws:batch:region:account:job/9b979cce-9da0-446d-90e2-ffa16d52af68",
"jobName": "myFirstEksMnpJob",
"jobId": ""
}
```
Vous pouvez vérifier l'état de la tâche à l'aide du JoBid renvoyé à l'aide de la commande suivante.
```
aws batch describe-jobs --jobs
```
# Remplacer une définition de tâche Amazon EKS MNP
Vous pouvez éventuellement remplacer les détails de la définition de la tâche (par exemple, modifier la taille de la tâche MNP ou les détails de la tâche enfant). Vous trouverez ci-dessous un exemple de charge utile de demande JSON pour soumettre une tâche MNP à cinq nœuds, ainsi que les modifications apportées à la commande du `test-eks-container-1` conteneur.
```
{
"numNodes": 5,
"nodePropertyOverrides": [
{
"targetNodes": "0:",
"eksPropertiesOverride": {
"podProperties": {
"containers": [
{
"name": "test-eks-container-1",
"command": [
"sleep",
"150"
]
}
]
}
}
}
]
}
```
Pour soumettre une tâche avec ces remplacements, enregistrez l'exemple dans un fichier local, *eks-mnp-job-nodeoverride.json*, et utilisez le AWS CLI pour soumettre le travail avec les remplacements.
# Tâches liées à
Une tâche matricielle est une tâche qui partage des paramètres communs, tels que la définition de la tâcheCPUs, v et la mémoire. Il s'exécute comme un ensemble de tâches de base connexes mais distinctes qui peuvent être distribuées sur plusieurs hôtes et peuvent s'exécuter simultanément. Les tâches matricielles constituent le moyen le plus efficace d'exécuter des tâches extrêmement parallèles, telles que des simulations de Monte Carlo, des balayages paramétriques ou des tâches de rendu de grande envergure.
AWS Batch les tâches matricielles sont soumises comme les tâches normales. Cependant, vous spécifiez une taille de tableau (entre 2 et 10 000) pour définir le nombre de tâches enfants devant s'exécuter dans le tableau. Si vous envoyez une tâche avec une taille de tableau 1 000, une seule tâche s'exécute et génère 1 000 tâches enfants. La tâche de tableau est une référence ou un pointeur pour gérer toutes les tâches enfants. Ainsi, vous pouvez soumettre des charges de travail importantes en une seule requête. Le délai spécifié dans le `attemptDurationSeconds` paramètre s'applique à chaque tâche enfant. La tâche du tableau parent n'a pas de délai d'expiration.
Lorsque vous soumettez une tâche matricielle, la tâche matricielle parent reçoit un ID de AWS Batch tâche normal. Chaque tâche secondaire possède le même identifiant de base. Toutefois, l'index du tableau pour le travail enfant est ajouté à la fin de l'ID parent, par exemple `example_job_ID:0` pour le premier travail enfant du tableau.
La tâche de matrice parent peut entrer un `SUCCEEDED` statut `SUBMITTED` `PENDING``FAILED`,, ou. Une tâche parent de tableau est mise à jour `PENDING` lorsqu'une tâche enfant est mise à jour vers`RUNNABLE`. Pour plus d'informations sur les interdépendances entre les emplois, consultez[Dépendances professionnelles](job_dependencies.md).
Lors de l'exécution, la variable d'environnement `AWS_BATCH_JOB_ARRAY_INDEX` est définie sur le numéro d'index de tableau de la tâche correspondant du conteneur. Le premier index des tâches du tableau est numéroté`0`, et les tentatives suivantes sont classées par ordre croissant (par exemple, 1, 2 et 3). Vous pouvez utiliser cette valeur d'index pour contrôler la façon dont les enfants de votre tâche de tableau sont différenciés. Pour de plus amples informations, veuillez consulter [Utilisez l'index des tâches matriciel pour contrôler la différenciation des tâches](array_index_example.md).
Pour les dépendances de tâches de tableau, vous pouvez spécifier un type pour une dépendance, comme `SEQUENTIAL` ou `N_TO_N`. Vous pouvez spécifier un type de dépendance `SEQUENTIAL` (sans spécifier d'ID de tâche), afin que chaque tâche de tableau enfant se termine de façon séquentielle à partir de l'index 0. Par exemple, si vous envoyez une tâche de tableau dont la taille de tableau est 100, et que vous spécifiez une dépendance de type `SEQUENTIAL`, 100 tâches enfants sont générées de façon séquentielle, et la première tâche enfant doit être effectuée avant que la tâche enfant suivante ne commence. Le schéma ci-dessous montre une Tâche A, une tâche de tableau de taille 10. Chaque tâche de l'index enfant de la Tâche A dépend de la tâche enfant précédente. La tâche A :1 ne peut pas commencer tant que la tâche A :0 n'est pas terminée.
![\[Flowchart showing Job-A with sequential child jobs A:0 through A:9, connected by arrows.\]](http://docs.aws.amazon.com/fr_fr/batch/latest/userguide/images/sequential-dep.png)
Vous pouvez également spécifier une dépendance de type `N_TO_N` avec un ID de tâche pour les tâches de tableau. Ainsi, chaque enfant de l'index de cette tâche doive attendre que l'enfant de l'index correspondant de chaque dépendance soit terminé avant de pouvoir commencer. La figure suivante montre le Job A et le Job B, deux tâches matricielles d'une taille de tableau de 10 000 chacune. Chaque tâche de l'index enfant de la Tâche B dépend de l'index correspondant de la Tâche A. Tâche B:1 ne peut pas démarrer tant que Tâche A:1 n'est pas terminée.
![\[Two array jobs, Job-A and Job-B, with 10,000 indexed tasks each, showing N_TO_N dependency.\]](http://docs.aws.amazon.com/fr_fr/batch/latest/userguide/images/n-to-n-dep.png)
Si vous annulez ou mettez fin à une tâche de la baie parent, toutes les tâches enfants sont annulées ou terminées en même temps. Vous pouvez annuler ou mettre fin à des emplois individuels pour enfants (ce qui les fait passer à un `FAILED` statut) sans affecter les autres emplois pour enfants. Toutefois, si une tâche de matrice enfant échoue (seule ou en annulant ou en mettant fin manuellement à la tâche), la tâche parent échoue également. Dans ce scénario, le travail du parent passe à celui `FAILED` où tous les emplois des enfants sont terminés.
Pour plus d'informations sur la recherche et le filtrage des tâches de matrice, consultez[Rechercher des offres d'emploi dans une file d'attente](searching-filtering-jobs.md).
**Topics**
+ [Exemple de flux de travail sur une matrice](example_array_job.md)
+ [Utilisez l'index des tâches matriciel pour contrôler la différenciation des tâches](array_index_example.md)
# Exemple de flux de travail sur une matrice
Un flux de travail courant pour les AWS Batch clients consiste à exécuter une tâche de configuration préalable, à exécuter une série de commandes sur un grand nombre de tâches d'entrée, puis à terminer par une tâche qui agrège les résultats et écrit des données récapitulatives sur Amazon S3, DynamoDB, Amazon Redshift ou Aurora.
Par exemple :
+ `JobA`: tâche standard, hors matrice, qui effectue une liste rapide et une validation des métadonnées des objets d'un compartiment Amazon S3,`BucketA`. La syntaxe [SubmitJob](https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitJob.html)JSON est la suivante.
```
{
"jobName": "JobA",
"jobQueue": "ProdQueue",
"jobDefinition": "JobA-list-and-validate:1"
}
```
+ `JobB`: une tâche matricielle de 10 000 copies qui en dépend `JobA` qui exécute des commandes gourmandes en ressources processeur sur chaque objet `BucketA` et télécharge les résultats vers. `BucketB` La syntaxe [SubmitJob](https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitJob.html)JSON est la suivante.
```
{
"jobName": "JobB",
"jobQueue": "ProdQueue",
"jobDefinition": "JobB-CPU-Intensive-Processing:1",
"containerOverrides": {
"resourceRequirements": [
{
"type": "MEMORY",
"value": "4096"
},
{
"type": "VCPU",
"value": "32"
}
]
}
"arrayProperties": {
"size": 10000
},
"dependsOn": [
{
"jobId": "JobA_job_ID"
}
]
}
```
+ `JobC`: une autre tâche de matrice de 10 000 copies qui dépend `JobB` d'un modèle de `N_TO_N` dépendance, qui exécute des commandes gourmandes en mémoire sur chaque élément contenu`BucketB`, écrit des métadonnées dans DynamoDB et télécharge le résultat obtenu vers. `BucketC` La syntaxe [SubmitJob](https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitJob.html)JSON est la suivante.
```
{
"jobName": "JobC",
"jobQueue": "ProdQueue",
"jobDefinition": "JobC-Memory-Intensive-Processing:1",
"containerOverrides": {
"resourceRequirements": [
{
"type": "MEMORY",
"value": "32768"
},
{
"type": "VCPU",
"value": "1"
}
]
}
"arrayProperties": {
"size": 10000
},
"dependsOn": [
{
"jobId": "JobB_job_ID",
"type": "N_TO_N"
}
]
}
```
+ `JobD`: tâche matricielle qui exécute 10 étapes de validation, chacune devant interroger DynamoDB et susceptible d'interagir avec l'un des compartiments Amazon S3 ci-dessus. Chacune des étapes de la procédure `JobD` exécute la même commande. Cependant, le comportement est différent en fonction de la valeur de la variable d'`AWS_BATCH_JOB_ARRAY_INDEX`environnement dans le conteneur de la tâche. Ces étapes de validation s'exécutent de manière séquentielle (par exemple, `JobD:0` puis`JobD:1`). La syntaxe [SubmitJob](https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitJob.html)JSON est la suivante.
```
{
"jobName": "JobD",
"jobQueue": "ProdQueue",
"jobDefinition": "JobD-Sequential-Validation:1",
"containerOverrides": {
"resourceRequirements": [
{
"type": "MEMORY",
"value": "32768"
},
{
"type": "VCPU",
"value": "1"
}
]
}
"arrayProperties": {
"size": 10
},
"dependsOn": [
{
"jobId": "JobC_job_ID"
},
{
"type": "SEQUENTIAL"
},
]
}
```
+ `JobE`: tâche finale, hors matrice, qui effectue quelques opérations de nettoyage simples et envoie une notification Amazon SNS avec un message indiquant que le pipeline est terminé et un lien vers l'URL de sortie. La syntaxe [SubmitJob](https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitJob.html)JSON est la suivante.
```
{
"jobName": "JobE",
"jobQueue": "ProdQueue",
"jobDefinition": "JobE-Cleanup-and-Notification:1",
"parameters": {
"SourceBucket": "s3://amzn-s3-demo-source-bucket",
"Recipient": "pipeline-notifications@mycompany.com"
},
"dependsOn": [
{
"jobId": "JobD_job_ID"
}
]
}
```
# Utilisez l'index des tâches matriciel pour contrôler la différenciation des tâches
Ce didacticiel explique comment utiliser la variable d'`AWS_BATCH_JOB_ARRAY_INDEX`environnement pour différencier les emplois pour enfants. Chaque tâche enfant est affectée à cette variable. L'exemple utilise le numéro d'index de la tâche enfant pour lire une ligne spécifique dans un fichier. Ensuite, il remplace le paramètre associé à ce numéro de ligne par une commande dans le conteneur de la tâche. Le résultat est que vous pouvez avoir plusieurs AWS Batch tâches qui exécutent la même image Docker et les mêmes arguments de commande. Cependant, les résultats sont différents car l'index des tâches du tableau est utilisé comme modificateur.
Dans ce didacticiel, vous créez un fichier texte qui contient toutes les couleurs de l'arc-en-ciel, chacune sur sa propre ligne. Vous créez ensuite un script de point d'entrée pour un conteneur Docker qui convertit l'index en une valeur pouvant être utilisée comme numéro de ligne dans le fichier couleur. L'indice commence à zéro, mais les numéros de ligne commencent à un. Créez un Dockerfile qui copie les fichiers de couleur et d'index sur l'image du conteneur et définit `ENTRYPOINT` l'image dans le script du point d'entrée. Le Dockerfile et les ressources sont créés à partir d'une image Docker transmise à Amazon ECR. Vous enregistrez ensuite une définition de tâche qui utilise votre nouvelle image de conteneur, vous soumettez une tâche AWS Batch matricielle avec cette définition de tâche et vous visualisez les résultats.
**Topics**
+ [Conditions préalables](array-tutorial-prereqs.md)
+ [Création d'une image de conteneur](build-index-container.md)
+ [Transférez votre image sur Amazon ECR](push-array-image.md)
+ [Création et enregistrement d'une définition de tâche](create-array-job-def.md)
+ [Soumettre une tâche AWS Batch matricielle](submit-array-job.md)
+ [Afficher les journaux des tâches de votre matrice](#array-tutorial-logs)
# Conditions préalables
Ce flux de travail didactique comporte les prérequis suivants :
+ Un environnement AWS Batch informatique. Pour de plus amples informations, veuillez consulter [Création d'un environnement informatique](create-compute-environment.md).
+ Une file AWS Batch d'attente de tâches et un environnement informatique associé. Pour de plus amples informations, veuillez consulter [Création d'une file d'attente de tâches](create-job-queue.md).
+ Ils AWS CLI sont installés sur votre système local. Pour plus d'informations, reportez-vous à la section [>Installation du AWS Command Line Interface dans le](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) *guide de l'AWS Command Line Interface utilisateur*.
+ Docker installé sur votre système local. Pour en savoir plus, consultez la section [À propos de Docker CE](https://docs.docker.com/install/) dans la documentation Docker.
# Création d'une image de conteneur
Vous pouvez utiliser le `AWS_BATCH_JOB_ARRAY_INDEX` dans une définition de tâche dans le paramètre de commande. Toutefois, nous vous recommandons de créer une image de conteneur qui utilise plutôt la variable dans un script de point d'entrée. Cette section décrit comment créer une image de conteneur de ce type.
**Pour créer votre image de conteneur Docker**
1. Créez un répertoire à utiliser en tant qu'espace de travail de votre image Docker et accédez à celui-ci.
1. Créez un fichier nommé `colors.txt` dans le répertoire de votre espace de travail et collez-y le texte suivant.
```
red
orange
yellow
green
blue
indigo
violet
```
1. Créez un fichier nommé `print-color.sh` dans le répertoire de votre espace de travail et collez-y le texte suivant.
**Note**
La variable `LINE` est définie sur le code `AWS_BATCH_JOB_ARRAY_INDEX` \$1 1 car l'index de tableau commence à 0 mais les numéros de ligne commencent à 1. La `COLOR` variable est définie sur la couleur associée à son numéro de ligne. `colors.txt`
```
#!/bin/sh
LINE=$((AWS_BATCH_JOB_ARRAY_INDEX + 1))
COLOR=$(sed -n ${LINE}p /tmp/colors.txt)
echo My favorite color of the rainbow is $COLOR.
```
1. Créez un fichier nommé `Dockerfile` dans le répertoire de votre espace de travail et collez-y le contenu suivant. Ce Dockerfile copie les fichiers précédents vers votre conteneur et définit le script de point d'entrée à exécuter au lancement du conteneur.
```
FROM busybox
COPY print-color.sh /tmp/print-color.sh
COPY colors.txt /tmp/colors.txt
RUN chmod +x /tmp/print-color.sh
ENTRYPOINT /tmp/print-color.sh
```
1. Générez votre image Docker.
```
$ docker build -t print-color .
```
1. Testez votre conteneur avec le script suivant. Ce script définit la `AWS_BATCH_JOB_ARRAY_INDEX` variable sur 0 localement, puis l'incrémente pour simuler ce que fait une tâche matricielle avec sept enfants.
```
$ AWS_BATCH_JOB_ARRAY_INDEX=0
while [ $AWS_BATCH_JOB_ARRAY_INDEX -le 6 ]
do
docker run -e AWS_BATCH_JOB_ARRAY_INDEX=$AWS_BATCH_JOB_ARRAY_INDEX print-color
AWS_BATCH_JOB_ARRAY_INDEX=$((AWS_BATCH_JOB_ARRAY_INDEX + 1))
done
```
En voici la sortie.
```
My favorite color of the rainbow is red.
My favorite color of the rainbow is orange.
My favorite color of the rainbow is yellow.
My favorite color of the rainbow is green.
My favorite color of the rainbow is blue.
My favorite color of the rainbow is indigo.
My favorite color of the rainbow is violet.
```
# Transférez votre image sur Amazon ECR
Maintenant que vous avez créé et testé votre conteneur Docker, transférez-le vers un référentiel d'images. Cet exemple utilise Amazon ECR, mais vous pouvez utiliser un autre registre, tel que DockerHub.
1. Créez un référentiel d'images Amazon ECR pour stocker l'image de votre conteneur. Cet exemple utilise uniquement le AWS CLI, mais vous pouvez également utiliser le AWS Management Console. Pour plus d'informations, consultez la section [Création d'un référentiel](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html) dans le *guide de l'utilisateur d'Amazon Elastic Container Registry*.
```
$ aws ecr create-repository --repository-name print-color
```
1. Marquez votre `print-color` image avec l'URI de votre référentiel Amazon ECR renvoyé à l'étape précédente.
```
$ docker tag print-color aws_account_id.dkr.ecr.region.amazonaws.com/print-color
```
1. Connectez-vous à votre registre Amazon ECR. Pour plus d'informations, veuillez consulter [Authentification de registre](https://docs.aws.amazon.com/AmazonECR/latest/userguide/Registries.html#registry_auth) dans le *Guide de l'utilisateur Amazon Elastic Container Registry*.
```
$ aws ecr get-login-password \
--region region | docker login \
--username AWS \
--password-stdin aws_account_id.dkr.ecr.region.amazonaws.com
```
1. Transférez votre image sur Amazon ECR.
```
$ docker push aws_account_id.dkr.ecr.region.amazonaws.com/print-color
```
# Création et enregistrement d'une définition de tâche
Maintenant que votre image Docker se trouve dans un registre d'images, vous pouvez la spécifier dans une définition de AWS Batch tâche. Vous pourrez ensuite l'utiliser ultérieurement pour exécuter une tâche matricielle. Cet exemple utilise uniquement le AWS CLI. Cependant, vous pouvez également utiliser le AWS Management Console. Pour de plus amples informations, veuillez consulter [Création d'une définition de tâche à nœud unique](create-job-definition.md).
**Pour créer une définition de tâche**
1. Créez un fichier nommé `print-color-job-def.json` dans le répertoire de votre espace de travail et collez-y le texte suivant. Remplacez l'URI du référentiel d'images par l'URI de votre image.
```
{
"jobDefinitionName": "print-color",
"type": "container",
"containerProperties": {
"image": "aws_account_id.dkr.ecr.region.amazonaws.com/print-color",
"resourceRequirements": [
{
"type": "MEMORY",
"value": "250"
},
{
"type": "VCPU",
"value": "1"
}
]
}
}
```
1. Enregistrez la définition de tâche auprès de AWS Batch.
```
$ aws batch register-job-definition --cli-input-json file://print-color-job-def.json
```
# Soumettre une tâche AWS Batch matricielle
Après avoir enregistré votre définition de tâche, vous pouvez soumettre une tâche AWS Batch matricielle qui utilise votre nouvelle image de conteneur.
**Pour soumettre une tâche AWS Batch matricielle**
1. Créez un fichier nommé `print-color-job.json` dans le répertoire de votre espace de travail et collez-y le texte suivant.
**Note**
Cet exemple utilise la file d'attente des tâches mentionnée dans la [Conditions préalables](array-tutorial-prereqs.md) section.
```
{
"jobName": "print-color",
"jobQueue": "existing-job-queue",
"arrayProperties": {
"size": 7
},
"jobDefinition": "print-color"
}
```
1. Soumettez le travail à votre AWS Batch file d'attente. Notez l'ID de tâche renvoyé dans la sortie.
```
$ aws batch submit-job --cli-input-json file://print-color-job.json
```
1. Décrivez l'état de la tâche et attendez que la tâche passe à `SUCCEEDED`.
## Afficher les journaux des tâches de votre matrice
Une fois que votre tâche a atteint le `SUCCEEDED` statut, vous pouvez consulter les CloudWatch journaux depuis le conteneur de la tâche.
**Pour consulter les journaux de votre travail dans CloudWatch Logs**
1. Ouvrez la AWS Batch console à l'adresse [https://console.aws.amazon.com/batch/](https://console.aws.amazon.com/batch/).
1. Dans le panneau de navigation de gauche, choisissez **Tâches**.
1. Pour **Files d'attente**, sélectionnez une file d'attente.
1. Dans la section **État**, choisissez **succès**.
1. Pour afficher toutes les tâches enfants de votre tâche de tableau, sélectionnez l'ID de tâche qui a été renvoyé à la section précédente.
1. Pour afficher les journaux du conteneur de la tâche, sélectionnez l'une des tâches enfants et choisissez **Afficher les journaux**.
![\[Journaux des conteneurs de tâches Array\]](http://docs.aws.amazon.com/fr_fr/batch/latest/userguide/images/array-logs.png)
1. Affichez les journaux des autres tâches enfants. Chaque tâche renvoie une couleur différente de l'arc-en-ciel.
# Exécuter des tâches GPU
Les tâches GPU vous aident à exécuter des tâches qui utilisent celles d'une instance GPUs.
Les types d'instances GPU Amazon EC2 suivants sont pris en charge. [https://aws.amazon.com/ec2/instance-types/trn2/](https://aws.amazon.com/ec2/instance-types/trn2/) [ 2 instances Dl1 et instances](https://aws.amazon.com/ec2/instance-types/dl1/) [Amazon EC2 Dl2.](https://aws.amazon.com/ec2/instance-types/dl2q/)
| Type d’instance | GPUs | Mémoire GPU | v CPUs | Mémoire | Bande passante du réseau |
| --- | --- | --- | --- | --- | --- |
| g3s.xlarge | 1 | 8 GiO | 4 | 30,5 GiB | 10 Gbit/s |
| g3.4xlarge | 1 | 8 GiO | 16 | 122 GiB | Jusqu'à 10 Gbit/s |
| g3.8xlarge | 2 | 16 GiO | 32 | 244 GiB | 10 Gbit/s |
| g3.16xlarge | 4 | 32 GiO | 64 | 488 GiB | 25 Gb/s |
| g4dn.xlarge | 1 | 16 GiO | 4 | 16 GiO | Jusqu'à 25 Gbit/s |
| g4dn.2xlarge | 1 | 16 GiO | 8 | 32 GiO | Jusqu'à 25 Gbit/s |
| g4dn.4xlarge | 1 | 16 GiO | 16 | 64 Go | Jusqu'à 25 Gbit/s |
| g4dn.8xlarge | 1 | 16 GiO | 32 | 128 Gio | 50 Gb/s |
| g4dn.12xlarge | 4 | 64 Go | 48 | 192 Go | 50 Gb/s |
| g4dn.16xlarge | 1 | 16 GiO | 64 | 256 Gio | 50 Gb/s |
| g5.xlarge | 1 | 24 GiO | 4 | 16 GiO | Jusqu'à 10 Gbit/s |
| g5.2xlarge | 1 | 24 GiO | 8 | 32 GiO | Jusqu'à 10 Gbit/s |
| g5.4xlarge | 1 | 24 GiO | 16 | 64 Go | Jusqu'à 25 Gbit/s |
| g5.8xlarge | 1 | 24 GiO | 32 | 128 Gio | 25 Gb/s |
| g5.16xlarge | 1 | 24 GiO | 64 | 256 Gio | 25 Gb/s |
| g5.12xlarge | 4 | 96 GiB | 48 | 192 Go | 40 Gbit/s |
| g5.24xlarge | 4 | 96 GiB | 96 | 384 Go | 50 Gb/s |
| g5.48xlarge | 8 | 192 Go | 192 | 768 Gio | 100 Gbit/s |
| g5g.xlarge | 1 | 16 GiO | 4 | 8 GiO | Jusqu'à 10 Gbit/s |
| g5g.2xlarge | 1 | 16 GiO | 8 | 16 GiO | Jusqu'à 10 Gbit/s |
| g5g.4xlarge | 1 | 16 GiO | 16 | 32 GiO | Jusqu'à 10 Gbit/s |
| g5g.8xlarge | 1 | 16 GiO | 32 | 64 Go | 12 Gb/s |
| g5g.16xlarge | 2 | 32 GiO | 64 | 128 Gio | 25 Gb/s |
| g5g.metal | 2 | 32 GiO | 64 | 128 Gio | 25 Gb/s |
| g6.xlarge | 1 | 24 GiO | 4 | 16 GiO | Jusqu'à 10 Gbit/s |
| g6.2xlarge | 1 | 24 GiO | 8 | 32 GiO | Jusqu'à 10 Gbit/s |
| g6.4xlarge | 1 | 24 GiO | 16 | 64 Go | Jusqu'à 25 Gbit/s |
| g6.8xlarge | 1 | 24 GiO | 32 | 128 Gio | 25 Gb/s |
| g6.16xlarge | 1 | 24 GiO | 64 | 256 Gio | 25 Gb/s |
| g6.12xlarge | 4 | 96 GiB | 48 | 192 Go | 40 Gbit/s |
| g6.24xlarge | 4 | 96 GiB | 96 | 384 Go | 50 Gb/s |
| g6.48xlarge | 8 | 192 Go | 192 | 768 Gio | 100 Gbit/s |
| g6e.xlarge | 1 | 48 GiO | 4 | 32 GiO | Jusqu'à 20 Gbit/s |
| g6e.2xlarge | 1 | 48 GiO | 8 | 64 Go | Jusqu'à 20 Gbit/s |
| g6e.4xlarge | 1 | 48 GiO | 16 | 128 Gio | 20 Gbit/s |
| g6e.8xlarge | 1 | 48 GiO | 32 | 256 Gio | 25 Gb/s |
| g6e.16xlarge | 1 | 48 GiO | 64 | 512 Gio | 35 Gbit/s |
| g6e.12xlarge | 4 | 192 Go | 48 | 384 Go | 100 Gbit/s |
| g6e.24xlarge | 4 | 192 Go | 96 | 768 Gio | 200 Gb/s |
| g6e.48xlarge | 8 | 384 Go | 192 | 1536 GiB | 400 Gb/s |
| gr6.4xlarge | 1 | 24 GiO | 16 | 128 Gio | Jusqu'à 25 Gbit/s |
| gr6.8xlarge | 1 | 24 GiO | 32 | 256 Gio | 25 Gb/s |
| p2.xlarge | 1 | 12 GiO | 4 | 61 GiB | Élevée |
| p2.8xlarge | 8 | 96 GiB | 32 | 488 GiB | 10 Gbit/s |
| p2.16xlarge | 16 | 192 Go | 64 | 732 GiB | 20 Gbit/s |
| p3.2xlarge | 1 | 16 GiO | 8 | 61 GiB | Jusqu'à 10 Gbit/s |
| p3.8xlarge | 4 | 64 Go | 32 | 244 GiB | 10 Gbit/s |
| p3.16xlarge | 8 | 128 Gio | 64 | 488 GiB | 25 Gb/s |
| p3dn.24xlarge | 8 | 256 Gio | 96 | 768 Gio | 100 Gbit/s |
| p4d.24xlarge | 8 | 320 GiB | 96 | 1152 GiB | 400 Gb/s |
| p4de.24xlarge | 8 | 640 GiB | 96 | 1152 GiB | 400 Gb/s |
| p5.48xlarge | 8 | 640 GiB | 192 | 2 Tio | 3200 Gbit/s |
| p5e.48xlarge | 8 | 1128 GiB | 192 | 2 Tio | 3200 Gbit/s |
| p5en.48xlarge | 8 | 1128 GiB | 192 | 2 Tio | 3200 Gbit/s |
| p6-b200.48xlarge | 8 | 1440 GiB | 192 | 2 Tio | 100 Gbit/s |
| trn1.2xlarge | 1 | 32 GiO | 8 | 32 GiO | Jusqu'à 12,5 Gbps |
| trn1.32xlarge | 16 | 512 Gio | 128 | 512 Gio | 800 Gb/s |
| trn1n.32xlarge | 16 | 512 Gio | 128 | 512 Gio | 1600 Gbit/s |
| trn2.48xlarge | 16 | 1,5 Tio | 192 | 2 Tio | 3,2 Tbit/s |
| inf1.xlarge | 1 | 8 GiO | 4 | 8 GiO | Jusqu'à 25 Gbit/s |
| inf1.2xlarge | 1 | 8 GiO | 8 | 16 GiO | Jusqu'à 25 Gbit/s |
| inf1.6xlarge | 4 | 32 GiO | 24 | 48 GiO | 25 Gb/s |
| inf1.24xlarge | 16 | 128 Gio | 96 | 192 Go | 100 Gbit/s |
| inf2.xlarge | 1 | 32 GiO | 4 | 16 GiO | Jusqu'à 15 Gbit/s |
| inf2.8xlarge | 1 | 32 GiO | 32 | 128 Gio | Jusqu'à 25 Gbit/s |
| inf2.24xlarge | 6 | 192 Go | 96 | 384 Go | 50 Gb/s |
| inf2.48xlarge | 12 | 384 Go | 192 | 768 Gio | 100 Gbit/s |
| dl1.24xlarge | 8 | 256 Gio | 96 | 768 Gio | 400 Gb/s |
| dl2q.24xlarge | 8 | 128 Gio | 96 | 768 Gio | 100 Gbit/s |
**Note**
Pour les tâches GPU, AWS Batch seuls les types d'instance dotés de NVIDIA sont pris en charge GPUs. Par exemple, la [https://aws.amazon.com/ec2/instance-types/g4/#Amazon_EC2_G4ad_instances](https://aws.amazon.com/ec2/instance-types/g4/#Amazon_EC2_G4ad_instances)famille n'est pas prise en charge pour la planification du GPU. Vous pouvez toujours utiliser cette option [https://aws.amazon.com/ec2/instance-types/g4/#Amazon_EC2_G4ad_instances](https://aws.amazon.com/ec2/instance-types/g4/#Amazon_EC2_G4ad_instances) AWS Batch en définissant uniquement les exigences en termes de processeur virtuel et de mémoire dans la définition de la tâche, puis en accédant directement aux GPU hôtes en personnalisant les données [utilisateur d'un modèle de lancement Amazon EC2](launch-templates.md#lt-user-data.title) avec une AMI optimisée pour le calcul Amazon ECS ou Amazon EKS, ou une AMI personnalisée pour l'utilisation d'AMD. GPUs
Les types d'instances qui utilisent une ARM64 architecture sont pris en charge pour les tâches GPU sur mesure AMIs fournies AWS Batch ou pour les données utilisateur Amazon EC2 permettant d'y accéder GPUs par un code et des configurations personnalisés. Par exemple, la famille d'[https://aws.amazon.com/ec2/instance-types/g5g/](https://aws.amazon.com/ec2/instance-types/g5g/)instances.
Le paramètre [ResourceRequirements](job_definition_parameters.md#ContainerProperties-resourceRequirements) pour la définition de tâche indique le nombre de GPUs à épingler au conteneur. Ce nombre de GPUs n'est disponible pour aucune autre tâche exécutée sur cette instance pendant la durée de cette tâche. Dans un environnement informatique, tous les types d'instances qui exécutent des tâches GPU doivent appartenir aux familles d'`g6`instances `p3` `p4` `p5` `p6` `g3``g3s`,`g4`,`g5`,,, ou. Si cela n'est pas fait, une tâche du GPU risque de rester bloquée dans l'`RUNNABLE`état.
Les tâches qui n'utilisent pas le GPUs peuvent être exécutées sur des instances de GPU. Cependant, leur exécution sur les instances GPU peut être plus coûteuse que sur des instances similaires non GPU. En fonction du vCPU, de la mémoire et du temps nécessaires, ces tâches non liées au GPU peuvent bloquer l'exécution des tâches GPU.
**Topics**
+ [Création d'un Kubernetes cluster basé sur un GPU sur Amazon EKS](create-gpu-cluster-eks.md)
+ [Création d'une définition de tâche GPU Amazon EKS](create-eks-gpu-job-definition.md)
+ [Exécuter une tâche GPU dans votre cluster Amazon EKS](run-gpu-job-eks-cluster.md)
# Création d'un Kubernetes cluster basé sur un GPU sur Amazon EKS
Avant de créer un Kubernetes cluster basé sur un GPU sur Amazon EKS, vous devez avoir effectué les étapes décrites dans. [Commencer à utiliser AWS Batch sur Amazon EKS](getting-started-eks.md) En outre, tenez également compte des points suivants :
+ AWS Batch prend en charge les types d'instances avec NVIDIA GPUs.
+ Par défaut, AWS Batch sélectionne l'AMI accélérée Amazon EKS avec la Kubernetes version qui correspond à la version de votre plan de contrôle du cluster Amazon EKS.
```
$ cat < ./batch-eks-gpu-ce.json
{
"computeEnvironmentName": "My-Eks-GPU-CE1",
"type": "MANAGED",
"state": "ENABLED",
"eksConfiguration": {
"eksClusterArn": "arn:aws:eks:::cluster/",
"kubernetesNamespace": "my-aws-batch-namespace"
},
"computeResources": {
"type": "EC2",
"allocationStrategy": "BEST_FIT_PROGRESSIVE",
"minvCpus": 0,
"maxvCpus": 1024,
"instanceTypes": [
"p3dn.24xlarge",
"p4d.24xlarge"
],
"subnets": [
""
],
"securityGroupIds": [
""
],
"instanceRole": ""
}
}
EOF
$ aws batch create-compute-environment --cli-input-json file://./batch-eks-gpu-ce.json
```
AWS Batch ne gère pas le plug-in du périphérique NVIDIA GPU à votre place. Vous devez installer ce plug-in dans votre cluster Amazon EKS et l'autoriser à cibler les AWS Batch nœuds. Pour plus d'informations, consultez la section [Activation du support GPU in Kubernetes](https://github.com/NVIDIA/k8s-device-plugin#enabling-gpu-support-in-kubernetes) on GitHub.
Pour configurer le plug-in de NVIDIA périphérique (`DaemonSet`) afin de cibler les AWS Batch nœuds, exécutez les commandes suivantes.
```
# pull nvidia daemonset spec
$ curl -O https://raw.githubusercontent.com/NVIDIA/k8s-device-plugin/v0.12.2/nvidia-device-plugin.yml
# using your favorite editor, add Batch node toleration
# this will allow the DaemonSet to run on Batch nodes
- key: "batch.amazonaws.com/batch-node"
operator: "Exists"
$ kubectl apply -f nvidia-device-plugin.yml
```
Nous vous déconseillons de mélanger des charges de travail basées sur le calcul (processeur et mémoire) avec des charges de travail basées sur le GPU dans les mêmes associations d'environnement informatique et de file d'attente de tâches. Cela est dû au fait que les tâches de calcul peuvent utiliser la capacité du GPU.
Pour attacher des files d'attente de tâches, exécutez les commandes suivantes.
```
$ cat < ./batch-eks-gpu-jq.json
{
"jobQueueName": "My-Eks-GPU-JQ1",
"priority": 10,
"computeEnvironmentOrder": [
{
"order": 1,
"computeEnvironment": "My-Eks-GPU-CE1"
}
]
}
EOF
$ aws batch create-job-queue --cli-input-json file://./batch-eks-gpu-jq.json
```
# Création d'une définition de tâche GPU Amazon EKS
Seule `nvidia.com/gpu` est prise en charge pour le moment et la valeur de ressource que vous définissez doit être un nombre entier. Vous ne pouvez pas utiliser de fractions de GPU. Pour plus d'informations, consultez la section [Planification GPUs](https://kubernetes.io/docs/tasks/manage-gpus/scheduling-gpus/) dans la *Kubernetesdocumentation*.
Pour enregistrer une définition de tâche GPU pour Amazon EKS, exécutez les commandes suivantes.
```
$ cat < ./batch-eks-gpu-jd.json
{
"jobDefinitionName": "MyGPUJobOnEks_Smi",
"type": "container",
"eksProperties": {
"podProperties": {
"hostNetwork": true,
"containers": [
{
"image": "nvcr.io/nvidia/cuda:10.2-runtime-centos7",
"command": ["nvidia-smi"],
"resources": {
"limits": {
"cpu": "1",
"memory": "1024Mi",
"nvidia.com/gpu": "1"
}
}
}
]
}
}
}
EOF
$ aws batch register-job-definition --cli-input-json file://./batch-eks-gpu-jd.json
```
# Exécuter une tâche GPU dans votre cluster Amazon EKS
La ressource GPU n'est pas compressible. AWS Batch crée une spécification de module pour les tâches GPU où la valeur de la **requête** est égale à la valeur des **limites**. Il s'agit d'une Kubernetes exigence.
Pour soumettre une tâche GPU, exécutez les commandes suivantes.
```
$ aws batch submit-job --job-queue My-Eks-GPU-JQ1 --job-definition MyGPUJobOnEks_Smi --job-name My-Eks-GPU-Job
# locate information that can help debug or find logs (if using Amazon CloudWatch Logs with Fluent Bit)
$ aws batch describe-jobs --job | jq '.jobs[].eksProperties.podProperties | {podName, nodeName}'
{
"podName": "aws-batch.f3d697c4-3bb5-3955-aa6c-977fcf1cb0ca",
"nodeName": "ip-192-168-59-101.ec2.internal"
}
```
# Afficher les AWS Batch tâches dans une file d'attente
Vous pouvez consulter et filtrer vos offres d'emploi dans AWS Batch. Cette fonctionnalité permet d'afficher une file d'attente de tâches existante et de filtrer ses tâches selon l'une des trois options suivantes.
La recherche et le filtrage permettent de récupérer des tâches qui ne sont pas dans un état terminal (`SUCCEEDED`ou`FAILED`). Une fois que l'état d'une tâche est `SUCCEEDED` atteint, `FAILED` vous devriez être en mesure de la récupérer pendant sept jours au maximum. Vous pouvez toujours consulter les EventBridge journaux d'une offre d'emploi CloudWatch ou d'Amazon.
Utilisez cette procédure pour répertorier toutes les tâches d'une file d'attente de tâches dans la AWS Batch console. Vous pouvez éventuellement utiliser le champ **Filtrer les résultats** pour affiner les résultats en fonction des critères que vous spécifiez.
1. Accédez à la [console AWS Batch](https://console.aws.amazon.com/batch/home).
1. Dans le volet de navigation, sélectionnez **Jobs**.
1. Développez la liste déroulante des **files d'attente de tâches** et choisissez la file d'attente de tâches dans laquelle vous souhaitez effectuer la recherche.
**Note**
Vous ne pouvez rechercher des offres d'emploi que dans une seule file d'attente à la fois.
1. Dans le champ **Filtrer les résultats**, entrez les mots clés à inclure dans les résultats. Vous pouvez utiliser ce champ pour filtrer par **nom du Job**, **Status** ou **Job ID**. Selon la propriété, il se peut que vous deviez définir des opérateurs supplémentaires, tels que égal (=) ou contient (:).
**Note**
SageMaker Les files d'attente pour les tâches de formation prennent uniquement en charge le filtrage par **nom de tâche** et ID de **tâche**
1. Choisissez **Rechercher**.
# Rechercher AWS Batch des offres d'emploi dans une file d'attente
Vous pouvez rechercher et filtrer vos offres d'emploi à AWS Batch l'aide de la fonction de recherche d'emploi. Cette fonctionnalité permet de rechercher dans une file d'attente de tâches existante et de filtrer ses tâches.
La recherche et le filtrage permettent de récupérer des tâches qui ne sont pas dans un état terminal (`SUCCEEDED`ou`FAILED`). Une fois que l'état d'une tâche est `SUCCEEDED` atteint, `FAILED` vous devriez être en mesure de la récupérer pendant sept jours au maximum. Vous pouvez toujours consulter les EventBridge journaux d'une offre d'emploi CloudWatch ou d'Amazon.
Pour effectuer une recherche à l'aide de plusieurs critères simultanément, utilisez la fonction **de recherche avancée**. Par exemple, vous pouvez inclure l'un ou l'ensemble des filtres suivants : **statut**, **plage de dates** et **critères supplémentaires** (tels que le nom de la tâche, la définition de la tâche ou l'identifiant de la tâche).
## Rechercher des AWS Batch offres d'emploi (AWS Console)
Utilisez cette procédure pour rechercher les tâches dans une file d'attente de tâches dans la AWS Batch console.
1. Accédez à la [console AWS Batch](https://console.aws.amazon.com/batch/home).
1. Dans le volet de navigation, sélectionnez **Jobs**.
1. Activez la **recherche avancée**.
1. Développez la liste déroulante des **files d'attente de tâches** et choisissez la file d'attente de tâches dans laquelle vous souhaitez effectuer la recherche.
**Note**
Vous ne pouvez rechercher des offres d'emploi que dans une seule file d'attente à la fois.
1. Pour les **options de recherche** :
1. Pour la liste déroulante des **statuts**, vous pouvez choisir un ou plusieurs statuts sur lesquels filtrer. Pour plus d’informations, consultez [États de l'emploi](job_states.md) et [État du poste de service](service-job-status.md).
**Note**
Les parents des tâches matricielles sont informés `PENDING` lorsqu'une tâche enfant est mise à jour `RUNNABLE` et conservent `PENDING` leur statut pendant l'exécution des tâches enfants. Pour consulter ces emplois, filtrez par `PENDING` statut jusqu'à ce que tous les emplois secondaires atteignent l'état terminal.
1. Choisissez **Plage de dates** pour filtrer les résultats en fonction d'une plage de dates et d'heures.
+ Choisissez **le mode relatif** pour rechercher des emplois dont la date de création se situe dans un intervalle de temps à compter à rebours à partir de la date et de l'heure actuelles.
+ Choisissez **le mode Absolu** pour rechercher des emplois dont la date de création se situe dans une plage de dates et d'heures que vous spécifiez.
1. Dans le champ **Critères supplémentaires**, entrez les mots clés à inclure dans les résultats de recherche. Par exemple, vous pouvez utiliser ce champ pour effectuer une recherche par **nom du Job**, par **définition du Job**, par **ID du Job** ou par **identifiant de partage**. Selon la propriété, il se peut que vous deviez définir des opérateurs supplémentaires, tels que égal (=) ou contient (:).
**Note**
SageMaker Les files d'attente pour les tâches de formation prennent uniquement en charge le filtrage par **nom de tâche** et ID de **tâche**
**Note**
Lorsque vous filtrez par **identifiant de partage**, vous pouvez également spécifier le statut de la tâche. Il s'agit d'une exception à la restriction selon laquelle d'autres filtres excluent le filtrage du statut des tâches.
1. Choisissez **Rechercher**.
## Rechercher et filtrer les AWS Batch offres d'emploi (AWS CLI)
Utilisez cette procédure pour répertorier toutes les tâches d'une file d'attente avec le AWS CLI. Vous pouvez éventuellement utiliser le paramètre **-filters** pour affiner les résultats en fonction des critères que vous spécifiez.
------
#### [ Search job queue (AWS CLI) ]
Vous pouvez utiliser la commande [list-jobs](https://docs.aws.amazon.com/cli/latest/reference/batch/list-jobs.html) pour rechercher et filtrer une file d'attente de tâches.
Par exemple, vous pouvez effectuer une recherche dans une file d'attente de tâches en fonction du nom de la tâche :
```
aws batch list-jobs \
--job-queue my-job-queue \
--filters name=JOB_NAME,values="my-job"
```
Filtrez les offres d'emploi par identifiant de partage :
```
aws batch list-jobs \
--job-queue my-job-queue \
--filters name=SHARE_IDENTIFIER,values="my-share"
```
Lorsque vous filtrez par identifiant de partage, vous pouvez inclure le statut de la tâche :
```
aws batch list-jobs \
--job-queue my-job-queue \
--job-status RUNNING \
--filters name=SHARE_IDENTIFIER,values="my-share"
```
Dans l’exemple précédent, apportez les modifications suivantes :
+ *my-job-queue*Remplacez-le par le nom de votre file d'attente de tâches.
+ Remplacez *my-job* par le nom de votre poste.
+ *my-share*Remplacez-le par l'identifiant de partage selon lequel vous souhaitez filtrer.
------
#### [ Search service job queue (AWS CLI) ]
Vous pouvez utiliser cette [list-service-jobs](https://docs.aws.amazon.com/cli/latest/reference/batch/list-service-jobs.html)commande pour rechercher et filtrer une file d'attente de tâches de service.
Par exemple, vous pouvez effectuer une recherche dans une file d'attente de tâches de service en fonction du nom de la tâche :
```
aws batch list-service-jobs \
--job-queue my-sm-queue \
--filters name=JOB_NAME,values="my-sm-job"
```
Filtrez les tâches de service par identifiant de partage :
```
aws batch list-service-jobs \
--job-queue my-sm-queue \
--filters name=SHARE_IDENTIFIER,values="my-share"
```
Dans l’exemple précédent, apportez les modifications suivantes :
+ *my-sm-queue*Remplacez-le par le nom de votre file d'attente de tâches de service.
+ *my-sm-job*Remplacez-le par le nom de votre tâche de service.
+ *my-share*Remplacez-le par l'identifiant de partage selon lequel vous souhaitez filtrer.
------
# Modes de mise en réseau pour les AWS Batch tâches
Le tableau suivant décrit les modes de mise en réseau et leur utilisation typique pour les types de AWS Batch tâches. Consultez les liens dans la colonne « Type de travail » pour plus de détails concernant les considérations et les comportements.
| Type de tâche | Mode (s) réseau pris en charge | Usage typique |
| --- | --- | --- |
| [Tâche simple ECS-EC2](jobs.md) | host | Utilisé pour les charges de travail par lots les plus évolutives et les plus embarrassantes qui nécessitent uniquement une sortie vers un vPC défini dans l'environnement de calcul. |
| [Tâche parallèle à plusieurs nœuds ECS-EC2](multi-node-parallel-jobs.md) | awsvpc | Utilisé pour les charges de travail distribuées à plusieurs hôtes (nœuds) étroitement couplées, modélisées comme une tâche unique avec des communications coordonnées entre les nœuds de tâches. |
| [Tâche simple avec ECS-Fargate](when-to-use-fargate.md) | awsvpc | Un véritable système sans serveur pour des charges de travail par lots extrêmement parallèles. Modèle de travail d'isolation des conteneurs généralement le plus bas et le plus élevé. |
| [Tâche simple sur EKS-EC2](eks-jobs.md) | hôte et pod | Utilisé pour les charges de travail par lots hautement évolutives et extrêmement parallèles qui nécessitent uniquement une sortie vers un vPC défini dans l'environnement de calcul. La valeur par défaut est le réseau hôte. |
| [Tâche parallèle à nœuds multiples EKS-EC2](mnp-eks-jobs.md) | hôte et pod | Utilisé pour les charges de travail distribuées à plusieurs hôtes (nœuds) étroitement couplées, modélisées comme une tâche unique avec des communications coordonnées entre les nœuds du pod. La valeur par défaut est le réseau hôte. |
# Afficher les journaux des AWS Batch tâches dans CloudWatch Logs
Vous pouvez [configurer vos AWS Batch tâches](using_cloudwatch_logs.md#using_cloudwatch_logs.title) pour envoyer des informations de journal à Amazon CloudWatch Logs. Ainsi, vous pouvez consulter les différents journaux de vos tâches en un seul endroit pratique. Pour de plus amples informations, veuillez consulter [Utilisation CloudWatch des journaux avec AWS Batch](using_cloudwatch_logs.md).
Vous pouvez également utiliser les **journaux des tâches** dans la AWS Batch console pour surveiller ou résoudre les problèmes liés à une AWS Batch tâche.
1. Ouvrez la [AWS Batch console](https://console.aws.amazon.com/batch/home).
1. Choisissez **Tâches**. Pour des informations plus détaillées sur le tri et le filtrage des tâches dans la file d'attente des tâches, consultez [Afficher les AWS Batch tâches dans une file d'attente](view-jobs.md) et [Rechercher des offres d'emploi dans une file d'attente](searching-filtering-jobs.md)
1. Pour la **file d'attente des tâches**, choisissez la file d'attente des tâches que vous souhaitez.
**Astuce**
Si plusieurs tâches figurent dans la file d'attente, vous pouvez activer la **recherche et le filtrage** pour trouver une tâche plus rapidement. Pour de plus amples informations, veuillez consulter [Rechercher AWS Batch des offres d'emploi dans une file d'attente](searching-filtering-jobs.md).
1. Dans le **champ Statut**, choisissez le statut du poste que vous souhaitez.
1. Choisissez le travail que vous souhaitez et la page de **détails** s'ouvre.
1. Sur la page **Détails**, faites défiler la page vers le bas jusqu'au **nom du flux du journal** et choisissez le lien. Le lien ouvre la page Amazon CloudWatch Logs de la tâche.
1. (Facultatif) Si c'est la première fois que vous consultez les journaux, une autorisation peut vous être demandée.
Dans **Autorisation requise**, entrez**OK**, puis choisissez **Autoriser** pour accepter les CloudWatch frais Amazon.
**Note**
Pour révoquer votre autorisation d'encaisser des CloudWatch frais, procédez comme suit :
Dans le volet de navigation de gauche, choisissez **Permissions**.
Pour **Job logs**, choisissez **Edit**.
Désactivez la case à CloudWatch cocher **Autoriser le lot à utiliser**.
Sélectionnez **Enregistrer les modifications**.
# Consulter les informations relatives à l' AWS Batch emploi
Vous pouvez consulter les informations relatives à la AWS Batch tâche, telles que le statut, la définition de la tâche et les informations relatives au conteneur.
1. Ouvrez la [AWS Batch console](https://console.aws.amazon.com/batch/home).
1. Choisissez **Tâches**.
1. Pour la **file d'attente des tâches**, choisissez la file d'attente des tâches que vous souhaitez.
**Astuce**
Si plusieurs tâches figurent dans la file d'attente, vous pouvez activer la **recherche et filtrer** pour trouver une offre d'emploi plus rapidement. Pour de plus amples informations, veuillez consulter [Rechercher AWS Batch des offres d'emploi dans une file d'attente](searching-filtering-jobs.md).
1. Choisissez le poste que vous souhaitez.
**Note**
Vous pouvez également utiliser le AWS Command Line Interface (AWS CLI) pour afficher les détails d'une AWS Batch tâche. Pour plus d'informations, consultez [describe-jobs](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/describe-jobs.html) dans le manuel de référence des [AWS CLI commandes](https://docs.aws.amazon.com/cli/latest/reference/).