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.
# Démons gérés par Amazon ECS
Les démons gérés par Amazon ECS vous permettent de déployer et de gérer des agents logiciels, tels que des agents de sécurité, d'observabilité et de mise en réseau, au sein de votre infrastructure de conteneurs sur des instances gérées Amazon ECS. Les démons gérés dissocient la gestion du cycle de vie des démons des opérations des applications. Vous pouvez déployer, mettre à jour et surveiller les agents indépendamment, sans redéployer les charges de travail ni coordonner les modifications entre les services.
## Comment fonctionnent les daemons gérés
Pour utiliser Managed Daemons, enregistrez d'abord une définition de tâche de démon. Une définition de tâche daemon est un modèle qui décrit les conteneurs qui forment un daemon. Après avoir enregistré une définition de tâche de démon, créez-en un et associez-le à un cluster et à un ou plusieurs fournisseurs de capacité Amazon ECS Managed Instances. Amazon ECS garantit ensuite qu'une seule tâche daemon s'exécute sur chaque instance Amazon EC2 mise en service par le biais de ces fournisseurs de capacité.
Les démons ne lancent pas les instances de manière indépendante. Lorsque vous exécutez une tâche d'application sur un fournisseur de capacité d'instances gérées Amazon ECS, Amazon ECS approvisionne une instance Amazon EC2, lance d'abord la tâche daemon, puis transfère la tâche d'application vers. `RUNNING` Cette commande garantit que les fonctions transversales telles que la journalisation, le suivi et la collecte de métriques sont opérationnelles avant que votre application ne commence à traiter les demandes.
Les démons sont essentiels, par exemple pour la santé. Si une tâche daemon s'arrête, Amazon ECS vide et remplace automatiquement cette instance de conteneur. Ce comportement de réparation automatique garantit une couverture fiable des démons sur toutes les instances sans intervention manuelle.
Lorsque vous mettez à jour un daemon vers une nouvelle révision de définition de tâche, Amazon ECS effectue un déploiement progressif sur toutes les instances des fournisseurs de capacité associés. Pendant le déploiement, Amazon ECS draine simultanément un pourcentage configurable d'instances, approvisionne les instances de remplacement avec le daemon mis à jour et remplace automatiquement vos tâches de service Amazon ECS. Amazon ECS fournit une protection intégrée contre les disjoncteurs. Vous pouvez configurer un temps de cuisson et des CloudWatch alarmes afin qu'Amazon ECS surveille le déploiement après la mise à jour de toutes les instances et qu'il annule automatiquement en cas de problème.
## Principaux avantages
+ **Gestion du cycle de vie découplée** : mettez à jour les démons indépendamment des déploiements d'applications.
+ **Couverture garantie** : Amazon ECS garantit que les tâches du démon démarrent avant les tâches d'application sur chaque instance, afin que les fonctions transversales soient toujours disponibles.
+ **Mises à jour de version fiables** : lorsque vous mettez à jour la version d'un démon, Amazon ECS la déploie sur toutes les instances des fournisseurs de capacité associés, avec une protection intégrée contre les disjoncteurs et une annulation automatique pour garantir que chaque instance exécute la révision cible.
+ **Utilisation améliorée des ressources : l'**exécution d'une seule tâche daemon par instance élimine le sidecar-per-task modèle, réduisant ainsi la surcharge de ressources au sein de votre cluster.
+ **Réparation automatique des instances** : si une tâche de démon s'arrête ou devient défectueuse, Amazon ECS vide et remplace automatiquement cette instance de conteneur. Cela permet de maintenir une couverture fiable des démons sans intervention manuelle.
**Note**
Amazon ECS propose une stratégie de planification DAEMON pour les services Amazon ECS pour le type de lancement Amazon EC2. Managed Daemons est une nouvelle fonctionnalité conçue pour les instances gérées Amazon ECS afin de simplifier les déploiements de démons et de fournir de meilleures garanties de couverture des démons.
## Prise en main
Pour commencer, enregistrez une définition de tâche de démon spécifiant l'image de votre conteneur, puis créez un démon avec les fournisseurs de capacité associés dans votre cluster. Vous pouvez utiliser le AWS Management Console AWS CLI, CloudFormation, ou AWS SDKs. Pour step-by-step obtenir des instructions, voir[Création et gestion de démons](managed-daemons-create-manage.md).
# Définitions de tâches de démon
Une définition de tâche de démon est le modèle de votre démon. Les démons gérés Amazon ECS utilisent une ressource de définition de tâche dédiée, distincte des définitions de tâches Amazon ECS standard. Vous enregistrez une définition de tâche de démon pour spécifier l'image du conteneur, les besoins en ressources et la configuration de votre démon.
## Création d'une définition de tâche daemon
Vous pouvez créer une définition de tâche daemon en utilisant le AWS Management Console ou le AWS CLI.
### En utilisant le AWS Management Console
1. Ouvrez la console Amazon ECS. Dans le menu de navigation de gauche, choisissez **Définitions de tâches Daemon**.
1. Choisissez **Créer une nouvelle définition de tâche daemon**.
1. Pour la **famille de définitions de tâches Daemon**, entrez un nom unique. Le nom peut contenir jusqu'à 255 caractères alphanumériques, traits d'union et traits de soulignement.
1. (Facultatif) Pour **Rôle de tâche**, choisissez un rôle IAM qui accorde des autorisations aux applications exécutées dans vos conteneurs. Laissez ce champ vide si vos conteneurs ne vous appellent pas AWS APIs.
1. (Facultatif) Pour le **rôle d'exécution des tâches**, sélectionnez`ecsTaskExecutionRole`. Amazon ECS a besoin de ce rôle pour extraire des images de conteneurs et publier des journaux.
1. (Facultatif) Dans **Taille de la tâche**, spécifiez le processeur et la mémoire à réserver pour votre démon. Par exemple, `0.25 vCPU` et `512 MB` la mémoire.
1. Configurez les détails de votre conteneur :
+ **Nom du conteneur** - Entrez le nom de votre conteneur. Le nom peut contenir jusqu'à 255 caractères alphanumériques, traits d'union et traits de soulignement.
+ **Contenant essentiel** - Sélectionnez **Oui**. Chaque définition de tâche daemon nécessite au moins un conteneur essentiel. En cas de défaillance d'un conteneur essentiel, Amazon ECS arrête l'ensemble de la tâche.
+ **URI de l'image** - Entrez l'URI de l'image Docker. Vous pouvez parcourir les images Amazon ECR ou utiliser des images publiques provenant de Docker Hub ou d'autres registres.
1. (Facultatif) Configurez l'allocation des ressources, le bilan de santé, les variables d'environnement, la collecte de journaux et les balises selon les besoins.
1. Vérifiez votre configuration et choisissez **Create**.
### En utilisant le AWS CLI
Enregistrez une définition de tâche daemon en créant un fichier JSON et en utilisant la `register-daemon-task-definition` commande.
Voici un exemple de fichier JSON :
```
{
"family": "my-daemon-task",
"containerDefinitions": [
{
"name": "daemon-container",
"image": "public.ecr.aws/docker/library/busybox:latest",
"essential": true,
"command": ["sh", "-c", "while true; do echo 'Daemon running'; sleep 30; done"],
"memoryReservation": 512
}
]
}
```
Exécutez la commande suivante pour enregistrer la définition de la tâche du démon :
```
aws ecs register-daemon-task-definition --cli-input-json file://daemon-taskdef.json
```
## Paramètres de définition des tâches du démon
Vous pouvez utiliser les paramètres suivants lorsque vous enregistrez une définition de tâche daemon.
**Paramètres requis**
+ `family`- Le nom de famille de définition de la tâche. Cela regroupe plusieurs révisions de la même définition de tâche de démon.
+ `containerDefinitions`- Un tableau d'`DaemonContainerDefinition`objets décrivant les conteneurs de votre tâche daemon.
**Paramètres facultatifs**
+ `cpu`- Unités de processeur au niveau des tâches sous forme de chaîne (par exemple,`"256"`).
+ `memory`- Mémoire au niveau des tâches en MiB sous forme de chaîne (par exemple,). `"512"`
+ `taskRoleArn`- L'ARN du rôle IAM qui accorde des autorisations aux conteneurs de votre tâche daemon.
+ `executionRoleArn`- L'ARN du rôle IAM que l'agent de conteneur Amazon ECS utilise pour effectuer des appels d' AWS API en votre nom (par exemple, extraire des images depuis Amazon ECR).
+ `volumes`- Un ensemble d'`DaemonVolume`objets. Les volumes Daemon ne prennent en charge que les montages par liaison avec `host` et. `sourcePath` Les définitions de tâches Daemon ne prennent pas en charge Amazon EBS, Amazon EFS, FSx pour Windows File Server, les volumes Docker ou le stockage éphémère.
+ `tags`- Un tableau de paires clé-valeur pour étiqueter la définition de votre tâche daemon.
## Mode réseau
Les démons utilisent un mode `daemon_bridge` réseau spécial qu'Amazon ECS définit automatiquement. Vous ne pouvez pas spécifier de mode réseau dans la définition de la tâche du démon. Tous les démons d'une instance partagent un même espace de noms réseau et sont accessibles localement via une adresse IP statique de pont de démons (`169.254.172.2`pour ou pour IPv4). `fd00:ec2::172:2` IPv6 Les tâches d'application (autres que les démons) peuvent communiquer avec les démons à cette adresse sans configuration réseau supplémentaire.
Comme les démons s'exécutent dans un espace de noms réseau distinct de celui des tâches d'application, les tâches autres que les démons n'ont pas à se soucier des conflits de port avec les démons. Cependant, étant donné que toutes les tâches de démon partagent le même espace de noms, les démons d'une même instance ne peuvent pas se lier au même port. Lorsque vous déployez plusieurs daemons, assurez-vous que chaque daemon utilise un port unique.
## Capacités privilégiées
Sur les instances gérées Amazon ECS, les démons prennent en charge les fonctionnalités Linux privilégiées pour les opérations au niveau du système. Les agents de sécurité, les outils de surveillance du réseau et les agents d'observabilité ont souvent besoin d'un accès au niveau du noyau pour fonctionner correctement.
Vous pouvez octroyer des capacités de deux manières :
**Le mode privilégié complet** accorde toutes les fonctionnalités Linux au conteneur. Utilisez-le lorsque votre agent a besoin d'un accès étendu au système :
```
{
"containerDefinitions": [{
"name": "security-daemon",
"image": "my-security-agent:latest",
"privileged": true
}]
}
```
**Les fonctionnalités individuelles** n'accordent que les autorisations dont votre démon a besoin, conformément au principe du moindre privilège. Utilisez le `linuxParameters.capabilities` champ pour ajouter des fonctionnalités individuelles telles que `SYS_ADMIN``NET_ADMIN`,`SYS_PTRACE`, et `BPF` :
```
{
"containerDefinitions": [{
"name": "monitoring-daemon",
"image": "my-monitoring-agent:latest",
"linuxParameters": {
"capabilities": {
"add": ["NET_ADMIN", "SYS_PTRACE"]
}
}
}]
}
```
## Volumes
Les démons gérés prennent en charge les montages par liaison à l'aide de volumes hôtes dotés d'une spécification. `sourcePath` Cela permet aux conteneurs daemon de monter des répertoires hôtes pour accéder aux journaux, aux métriques et aux informations système sur l'instance Amazon EC2 sous-jacente. Les agents de collecte de journaux, les exportateurs de métriques et les scanners de sécurité l'utilisent généralement pour gagner en visibilité sur les données au niveau de l'hôte.
La définition des tâches du démon prend en charge les spécifications du volume hôte avec`sourcePath`. Les volumes Daemon persistent pendant tout le cycle de vie de l'instance de conteneur sous-jacente.
**Note**
Les volumes Amazon EBS, les volumes Amazon EFS, FSx les volumes pour Windows File Server, les volumes Docker et le stockage éphémère ne sont pas pris en charge dans les définitions de tâches du démon.
**Note**
Les démons ne prennent pas en charge le partage de volume entre eux. Chaque daemon fonctionne avec sa propre configuration de volume indépendante.
L'exemple suivant montre un démon Log Collector doté d'un montage bind :
```
{
"containerDefinitions": [{
"name": "log-collector",
"image": "fluent/fluentd:latest",
"mountPoints": [{
"sourceVolume": "var-log",
"containerPath": "/var/log"
}]
}],
"volumes": [{
"name": "var-log",
"host": {
"sourcePath": "/var/log"
}
}]
}
```
## Paramètres de conteneur pris en charge
Les définitions de conteneurs Daemon prennent en charge les paramètres suivants :
+ `image`(obligatoire) - URI de l'image du conteneur
+ `name`(obligatoire) - Nom du conteneur
+ `cpu`- Unités CPU réservées au conteneur
+ `memory`/`memoryReservation`- Limites de mémoire matérielles et logicielles
+ `essential`- Si le conteneur est essentiel (valeur par défaut : true)
+ `command`/`entryPoint`- Remplacer la commande ou le point d'entrée du conteneur
+ `environment`/`environmentFiles`/`secrets`- Configuration de l'environnement
+ `privileged`- Exécuter le conteneur en mode privilégié
+ `user`- Utilisateur sous lequel exécuter le conteneur
+ `workingDirectory`- Répertoire de travail à l'intérieur du conteneur
+ `readonlyRootFilesystem`- Monter le système de fichiers racine en lecture seule
+ `mountPoints`- Points de montage des volumes (reliez les montages avec host et SourcePath uniquement)
+ `logConfiguration`- Configuration de journalisation (supporte awslogs, splunk, awsfirelens)
+ `healthCheck`- Configuration du contrôle de santé du conteneur
+ `dependsOn`- Dépendances de démarrage du conteneur
+ `ulimits`- Limites de ressources
+ `systemControls`- Paramètres du noyau
+ `linuxParameters.capabilities`- Fonctionnalités Linux à ajouter ou à supprimer
+ `linuxParameters.initProcessEnabled`- Exécute un processus d'initialisation dans le conteneur
+ `repositoryCredentials`- Informations d'identification pour les registres privés
+ `restartPolicy`- Politique de redémarrage des conteneurs
# Création et gestion de démons
Après avoir enregistré une définition de tâche de démon, créez-en un pour le déployer auprès de vos fournisseurs de capacité Amazon ECS Managed Instances. Amazon ECS place automatiquement une tâche de démon sur chaque instance Amazon EC2 dans les fournisseurs de capacité associés et gère le cycle de vie du démon.
## Conditions préalables
Avant de créer un daemon, vérifiez que vous disposez des éléments suivants :
+ Un cluster Amazon ECS.
+ Un ou plusieurs fournisseurs de capacité d'instances gérées Amazon ECS associés au cluster.
+ Définition d'une tâche daemon enregistrée.
## Création d'un daemon
### AWS Management Console
1. Ouvrez la console Amazon ECS. Dans le volet de navigation de gauche, choisissez **Clusters**, puis sélectionnez votre cluster.
1. **Cliquez sur l'onglet **Daemons**, puis sur Create.**
1. Pour la **famille de définitions de tâches Daemon, sélectionnez votre définition** de tâche daemon dans le menu déroulant.
1. Pour la **révision de la définition des tâches Daemon**, sélectionnez la révision à utiliser. Laissez ce champ vide pour utiliser la dernière révision.
1. Pour le **nom du démon**, entrez un nom unique. Le nom peut contenir jusqu'à 255 caractères alphanumériques, traits d'union et traits de soulignement.
1. Pour les **fournisseurs de capacité**, sélectionnez un ou plusieurs fournisseurs de capacité des instances gérées Amazon ECS. Ils déterminent les instances qui exécutent vos tâches de démon.
1. (Facultatif) Configurez les paramètres de déploiement :
+ **Pourcentage de vidange** : pourcentage d'instances à vider simultanément lors des mises à jour. Valeur par défaut : `25`.
+ **Utiliser une ou plusieurs CloudWatch alarmes** : activez-le pour surveiller l'état du déploiement et revenez automatiquement en arrière si des alarmes se déclenchent.
+ **Durée de cuisson** : nombre de minutes pendant lesquelles Amazon ECS attend une fois que toutes les instances ont été mises à jour avec la nouvelle version du daemon avant de terminer le déploiement. Pendant cette période, Amazon ECS surveille les CloudWatch alarmes et annule automatiquement le déploiement si une alarme se déclenche. Valeur par défaut : `0`.
1. (Facultatif) Ajoutez des balises.
1. (Facultatif) **Activez Enable ECS Exec** pour exécuter des commandes interactives dans vos conteneurs de démons à des fins de résolution des problèmes.
1. Vérifiez votre configuration et choisissez **Create**.
### AWS CLI
Créez un fichier JSON avec la configuration de votre daemon et exécutez la `create-daemon` commande.
Voici un exemple de fichier JSON :
```
{
"clusterArn": "arn:aws:ecs:us-east-1:123456789012:cluster/my-daemon-cluster",
"daemonName": "my-monitoring-daemon",
"daemonTaskDefinitionArn": "arn:aws:ecs:us-east-1:123456789012:daemon-task-definition/my-daemon-task:1",
"capacityProviderArns": [
"arn:aws:ecs:us-east-1:123456789012:capacity-provider/my-daemon-capacity-provider"
]
}
```
Exécutez la commande suivante pour créer le daemon :
```
aws ecs create-daemon --cli-input-json file://create-daemon.json
```
**Champs obligatoires**
+ `daemonName`- Un nom unique pour le daemon.
+ `clusterArn`- L'ARN du cluster.
+ `daemonTaskDefinitionArn`- L'ARN de la définition de la tâche du démon.
+ `capacityProviderArns`- Un éventail de fournisseurs de capacité pour les instances gérées Amazon ECS ARNs.
**Champs facultatifs**
+ `deploymentConfiguration`- Un `DaemonDeploymentConfiguration` objet pour personnaliser le comportement de déploiement.
+ `tags`- Paires clé-valeur pour le balisage.
+ `propagateTags`- Paramètre de propagation des balises.
+ `clientToken`- Un jeton d'impuissance.
## Vérification du déploiement du daemon
Après avoir créé un démon, vérifiez son statut à l'aide du AWS Management Console ou du AWS CLI.
### AWS Management Console
1. Ouvrez la console Amazon ECS. Dans le volet de navigation de gauche, choisissez **Clusters**, puis sélectionnez votre cluster.
1. Choisissez l'onglet **Daemons.**
1. Vérifiez que votre daemon affiche le statut **Actif**.
1. Choisissez l'onglet **Tâches** pour vérifier qu'une tâche daemon est exécutée sur chaque instance de conteneur.
### AWS CLI
Exécutez les commandes suivantes pour vérifier l'état du démon :
```
aws ecs list-daemons \
--cluster-arn arn:aws:ecs:us-east-1:123456789012:cluster/my-daemon-cluster
```
```
aws ecs describe-daemons \
--daemon-arn arn:aws:ecs:us-east-1:123456789012:daemon/my-daemon-cluster/my-monitoring-daemon
```
## Mettre à jour un daemon
Pour mettre à jour un daemon avec une nouvelle révision de définition de tâche ou pour ajouter des fournisseurs de capacité, utilisez le AWS Management Console ou le AWS CLI. Cela déclenche un déploiement continu sur toutes les instances.
### AWS Management Console
1. Ouvrez la console Amazon ECS. Dans le volet de navigation de gauche, choisissez **Clusters**, puis sélectionnez votre cluster.
1. Choisissez l'onglet **Daemons**, puis sélectionnez le daemon que vous souhaitez mettre à jour.
1. Choisissez **Mettre à jour**.
1. Pour la **révision de la définition des tâches Daemon**, sélectionnez la nouvelle révision.
1. (Facultatif) Mettez à jour les fournisseurs de capacité ou les paramètres de déploiement.
1. Choisissez **Mettre à jour** pour démarrer le déploiement progressif.
### AWS CLI
Exécutez la commande `update-daemon` :
```
aws ecs update-daemon \
--daemon-arn arn:aws:ecs:us-east-1:123456789012:daemon/my-daemon-cluster/my-monitoring-daemon \
--daemon-task-definition-arn arn:aws:ecs:us-east-1:123456789012:daemon-task-definition/my-daemon-task:2 \
--capacity-provider-arns arn:aws:ecs:us-east-1:123456789012:capacity-provider/my-daemon-capacity-provider
```
**Important**
Lorsque vous fournissez les paramètres de configuration du démon dans une `UpdateDaemon` demande, Amazon ECS utilise les paramètres que vous avez spécifiés au lieu des paramètres par défaut. Les paramètres de configuration du démon, y compris les balises et l'indicateur de commande enable execute, ne sont pas conservés entre les mises à jour. Chaque appel `UpdateDaemon` doit inclure l'ensemble complet des paramètres de configuration que vous souhaitez appliquer. Tous les paramètres omis dans la demande reprennent leurs valeurs par défaut.
## Supprimer un daemon
Pour supprimer un démon, utilisez le AWS Management Console ou le AWS CLI. Attendez que toutes les tâches du démon soient arrêtées avant de supprimer le fournisseur de capacité ou le cluster.
### AWS Management Console
1. Ouvrez la console Amazon ECS. Dans le volet de navigation de gauche, choisissez **Clusters**, puis sélectionnez votre cluster.
1. Choisissez l'onglet **Daemons**, puis sélectionnez le daemon que vous souhaitez supprimer.
1. Sélectionnez **Delete (Supprimer)**.
1. Dans la boîte de dialogue de confirmation, choisissez **Supprimer** pour confirmer.
### AWS CLI
Exécutez la commande `delete-daemon` :
```
aws ecs delete-daemon \
--daemon-arn arn:aws:ecs:us-east-1:123456789012:daemon/my-daemon-cluster/my-monitoring-daemon
```
# Déploiements de démons
Lorsque vous créez ou mettez à jour un démon, Amazon ECS effectue un déploiement progressif pour exécuter des tâches de démon sur toutes les instances des fournisseurs de capacité associés. Cette section décrit le fonctionnement des déploiements de démons et comment configurer le comportement de déploiement.
## Comment fonctionnent les déploiements de démons
Le déploiement d'un daemon suit un drain-provision-replace schéma. Lorsque vous créez un daemon sur un fournisseur de capacité avec des instances existantes, ou que vous mettez à jour un daemon en fonction d'une nouvelle révision de définition de tâche, Amazon ECS vide un lot d'instances, approvisionne les instances de remplacement avec le daemon mis à jour et remplace automatiquement les tâches d'application. Ce processus se répète jusqu'à ce que toutes les instances exécutent la nouvelle version du démon.
Le cycle de vie du déploiement passe par les états suivants :
1. `PENDING`- Amazon ECS a créé le déploiement et s'apprête à commencer.
1. `IN_PROGRESS`- Amazon ECS vide activement les instances et fournit des solutions de remplacement.
1. `SUCCESSFUL`- Toutes les instances exécutent la révision du démon cible.
1. `STOPPED`- Amazon ECS a arrêté le déploiement car il a échoué ou a été remplacé par un nouveau déploiement. Le démon peut être dans un état mixte dans lequel certaines instances exécutent l'ancienne révision et d'autres exécutent la nouvelle révision.
Amazon ECS revient automatiquement à la version précédente du daemon si le disjoncteur de déploiement détecte des défaillances ou si une CloudWatch alarme se déclenche pendant le déploiement.
## Paramètres de configuration du déploiement
Vous pouvez personnaliser le comportement de déploiement en utilisant le `deploymentConfiguration` paramètre lorsque vous créez ou mettez à jour un démon.
+ `drainPercent`(1,0—100,0) : pourcentage d'instances à vider simultanément pendant le déploiement. Des valeurs plus élevées accélèrent les déploiements mais peuvent réduire temporairement la capacité disponible. Par exemple, une valeur de `20.0` draine 20 % des instances à la fois. Si aucune valeur n'est spécifiée, la valeur par défaut est `25.0`.
+ `alarms`(`DaemonAlarmConfiguration`) - CloudWatch alarmes à surveiller pendant le déploiement. Amazon ECS évalue les alarmes spécifiées pendant le déploiement et les annule automatiquement si une alarme entre dans `ALARM` cet état. Amazon ECS ignore les alarmes déjà présentes lorsque `ALARM` le déploiement commence.
+ `bakeTimeInMinutes`(0—1440) - Le nombre de minutes pendant lesquelles Amazon ECS attend après avoir mis à jour toutes les instances avec la nouvelle révision du daemon avant de terminer le déploiement. Pendant cette période, Amazon ECS surveille les CloudWatch alarmes et annule automatiquement le déploiement si une alarme se déclenche. Si aucune valeur n'est spécifiée, la valeur par défaut est `0`.
**Exemple de configuration de déploiement :**
```
aws ecs create-daemon \
--cluster-arn arn:aws:ecs:us-east-1:123456789012:cluster/my-daemon-cluster \
--daemon-name my-monitoring-daemon \
--daemon-task-definition-arn arn:aws:ecs:us-east-1:123456789012:daemon-task-definition/my-daemon-task:1 \
--capacity-provider-arns arn:aws:ecs:us-east-1:123456789012:capacity-provider/my-daemon-capacity-provider \
--deployment-configuration '{"drainPercent":20.0,"bakeTimeInMinutes":5}'
```
## Surveillance des déploiements
Suivez la progression du déploiement à l'aide des commandes suivantes :
```
aws ecs list-daemon-deployments \
--daemon-arn arn:aws:ecs:us-east-1:123456789012:daemon/my-daemon-cluster/my-monitoring-daemon
```
```
aws ecs describe-daemon-deployments \
--daemon-deployment-arns arn:aws:ecs:us-east-1:123456789012:daemon-deployment/my-daemon-cluster/abc123
```
La `describe-daemon-deployments` réponse inclut l'état du déploiement, la version du démon cible et le `totalRunningInstanceCount` champ qui indique le nombre d'instances qui exécutent le démon cible.
## Scénarios de déploiement de daemon
Cette section décrit les scénarios de déploiement courants pour Managed Daemons.
+ [Déployer un daemon sur un fournisseur de capacité vide](#managed-daemons-scenario-empty)
+ [Déployer un daemon sur un fournisseur de capacité avec des instances existantes](#managed-daemons-scenario-existing)
+ [Ajouter un fournisseur de capacité à un daemon existant](#managed-daemons-scenario-add-cp)
+ [Mettre à jour un daemon vers une nouvelle révision](#managed-daemons-scenario-update)
### Déployer un daemon sur un fournisseur de capacité vide
Dans ce scénario, vous déployez un démon sur un fournisseur de capacité sans instance existante. Les instances sont lancées lorsque vous planifiez des tâches d'application.
**Conditions préalables :** un cluster et un fournisseur de capacité d'instances gérées Amazon ECS sans aucune instance en cours d'exécution.
1. Enregistrez la définition de votre tâche daemon.
1. Créez le daemon. Amazon ECS termine la création immédiatement, même si aucune instance n'existe encore.
```
aws ecs create-daemon \
--cluster-arn arn:aws:ecs:us-east-1:123456789012:cluster/my-daemon-cluster \
--daemon-name my-monitoring-daemon \
--daemon-task-definition-arn arn:aws:ecs:us-east-1:123456789012:daemon-task-definition/my-daemon-task:1 \
--capacity-provider-arns arn:aws:ecs:us-east-1:123456789012:capacity-provider/my-daemon-capacity-provider
```
1. Créez un service qui utilise le même fournisseur de capacité. Lorsqu'Amazon ECS provisionne une instance pour le service, il lance d'abord la tâche daemon, puis fait passer la tâche d'application à`RUNNING`.
```
aws ecs create-service \
--cluster my-daemon-cluster \
--service-name my-app-service \
--task-definition my-app-task \
--desired-count 2 \
--capacity-provider-strategy capacityProvider=my-daemon-capacity-provider,weight=1
```
1. Vérifiez que la tâche du démon est exécutée sur chaque instance à l'aide de la `describe-daemons` commande ou en consultant l'onglet **Daemons** de la console.
**Note**
Le déploiement du démon peut rester actif pendant une courte période `PENDING` pendant qu'Amazon ECS approvisionne les instances et lance les tâches du démon. Attendez que le déploiement soit terminé `SUCCESSFUL` avant de vérifier le placement des tâches du démon.
### Déployer un daemon sur un fournisseur de capacité avec des instances existantes
Dans ce scénario, vous déployez un démon sur un fournisseur de capacité qui possède déjà des instances et des tâches d'application en cours d'exécution.
**Conditions préalables :** un cluster doté d'un fournisseur de capacité Amazon ECS Managed Instances doté d'instances en cours d'exécution.
1. Enregistrez la définition de votre tâche daemon.
1. Créez le daemon. Amazon ECS lance un déploiement progressif pour placer des tâches daemon sur toutes les instances existantes.
```
aws ecs create-daemon \
--cluster-arn arn:aws:ecs:us-east-1:123456789012:cluster/my-daemon-cluster \
--daemon-name my-monitoring-daemon \
--daemon-task-definition-arn arn:aws:ecs:us-east-1:123456789012:daemon-task-definition/my-daemon-task:1 \
--capacity-provider-arns arn:aws:ecs:us-east-1:123456789012:capacity-provider/my-daemon-capacity-provider \
--deployment-configuration '{"drainPercent":25.0,"bakeTimeInMinutes":3}'
```
Amazon ECS vide un lot d'instances existantes (sur la base du`drainPercent`), approvisionne les instances de remplacement avec le daemon et remplace les tâches d'application. Ce processus se répète jusqu'à ce que toutes les instances exécutent le daemon.
1. Surveillez la progression du déploiement :
```
aws ecs list-daemon-deployments \
--daemon-arn arn:aws:ecs:us-east-1:123456789012:daemon/my-daemon-cluster/my-monitoring-daemon
```
### Ajouter un fournisseur de capacité à un daemon existant
Dans ce scénario, vous ajoutez un deuxième fournisseur de capacité à un daemon existant. Le daemon se déploie automatiquement sur les instances du nouveau fournisseur de capacité.
**Conditions préalables :** un démon s'exécutant sur un premier fournisseur de capacité, et un second fournisseur de capacité créé et associé au cluster.
1. Mettez à jour le daemon pour inclure les deux fournisseurs de capacité :
```
aws ecs update-daemon \
--daemon-arn arn:aws:ecs:us-east-1:123456789012:daemon/my-daemon-cluster/my-monitoring-daemon \
--daemon-task-definition-arn arn:aws:ecs:us-east-1:123456789012:daemon-task-definition/my-daemon-task:1 \
--capacity-provider-arns \
arn:aws:ecs:us-east-1:123456789012:capacity-provider/my-daemon-capacity-provider \
arn:aws:ecs:us-east-1:123456789012:capacity-provider/my-daemon-capacity-provider-2
```
1. Surveillez le déploiement et vérifiez que les tâches daemon s'exécutent sur les instances des deux fournisseurs de capacité.
### Mettre à jour un daemon vers une nouvelle révision
Dans ce scénario, vous mettez à jour un démon existant pour utiliser une nouvelle révision de définition de tâche.
1. Enregistrez une nouvelle révision de la définition de votre tâche daemon avec l'image ou la configuration du conteneur mise à jour.
1. Mettez à jour le daemon pour utiliser la nouvelle révision :
```
aws ecs update-daemon \
--daemon-arn arn:aws:ecs:us-east-1:123456789012:daemon/my-daemon-cluster/my-monitoring-daemon \
--daemon-task-definition-arn arn:aws:ecs:us-east-1:123456789012:daemon-task-definition/my-daemon-task:2
```
Amazon ECS effectue un déploiement progressif. Il vide les instances exécutant l'ancienne révision, approvisionne les instances de remplacement avec la nouvelle révision et remplace automatiquement les tâches d'application. Si le disjoncteur détecte des défaillances, Amazon ECS revient à la révision précédente.
1. Surveillez le déploiement et vérifiez que toutes les instances exécutent la nouvelle révision :
```
aws ecs describe-daemon-deployments \
--daemon-deployment-arns arn:aws:ecs:us-east-1:123456789012:daemon-deployment/my-daemon-cluster/deployment-id
```
# Événements Daemon
Amazon ECS envoie des événements liés aux démons pour fournir une visibilité sur la gestion des tâches des démons et les modifications du cycle de vie des déploiements. Vous pouvez utiliser ces événements pour surveiller l'état des démons, suivre la progression du déploiement et déclencher des flux de travail automatisés.
Amazon ECS prend en charge les types d'événements daemon suivants :
+ [Événements d'action du service Daemon](#managed-daemons-service-action-events)- Événements liés au placement des tâches du démon et aux problèmes de démarrage.
+ [Événements de modification de l'état du déploiement du démon](#managed-daemons-deployment-state-change-events)- Événements liés aux transitions du cycle de vie du déploiement des daemon.
Pour savoir comment créer des règles pour ces événements, consultez[Création de règles pour les événements daemon](#managed-daemons-eventbridge-rules).
## Événements d'action du service Daemon
Amazon ECS envoie des événements d'action du service daemon avec le type `ECS Daemon Service Action` détaillé. Ces événements vous avertissent lorsqu'Amazon ECS rencontre des problèmes lors du démarrage de tâches daemon sur vos instances de conteneur.
### DAEMON\$1TASK\$1START\$1IMPAIRED
Amazon ECS envoie l'`DAEMON_TASK_START_IMPAIRED`événement lorsqu'il ne parvient pas à démarrer une tâche daemon sur une instance de conteneur. L'événement inclut un `failureType` champ qui indique la cause de l'échec :
+ `TASK_FAILED_TO_RUN`- La tâche daemon a été créée mais n'a pas atteint `RUNNING` son statut. Les causes courantes incluent les échecs d'extraction des images du conteneur, les échecs de vérification de l'état du conteneur ou les sorties essentielles du conteneur. Le `taskArn` champ est présent dans l'événement.
+ `TASK_CREATION_FAILED`- La tâche daemon n'a pas pu être créée sur l'instance de conteneur. Les causes courantes incluent l'insuffisance du processeur, de la mémoire ou d'autres ressources sur l'instance. Le `taskArn` champ n'est pas présent dans l'événement car aucune tâche n'a été créée.
### Exemple : événement TASK\$1FAILED\$1TO\$1RUN
L'événement suivant montre une tâche daemon qui a été créée mais dont le `RUNNING` statut n'a pas été atteint en raison d'un échec de l'extraction de l'image du conteneur.
```
{
"version": "0",
"id": "12345678-1234-1234-1234-123456789012",
"detail-type": "ECS Daemon Service Action",
"source": "aws.ecs",
"account": "123456789012",
"time": "2026-03-24T12:00:00Z",
"region": "us-west-2",
"resources": [
"arn:aws:ecs:us-west-2:123456789012:task/my-cluster/a1b2c3d4e5f6"
],
"detail": {
"eventType": "WARNING",
"eventName": "DAEMON_TASK_START_IMPAIRED",
"clusterArn": "arn:aws:ecs:us-west-2:123456789012:cluster/my-cluster",
"containerInstanceArn": "arn:aws:ecs:us-west-2:123456789012:container-instance/my-cluster/a1b2c3d4e5f6",
"taskArn": "arn:aws:ecs:us-west-2:123456789012:task/my-cluster/a1b2c3d4e5f6",
"daemonRevisionArn": "arn:aws:ecs:us-west-2:123456789012:daemon-revision/my-cluster/my-daemon/a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"capacityProviderName": "my-capacity-provider",
"daemonArn": "arn:aws:ecs:us-west-2:123456789012:daemon/my-cluster/my-daemon",
"daemonTaskDefinitionArn": "arn:aws:ecs:us-west-2:123456789012:daemon-task-definition/my-daemon-td:1",
"failureType": "TASK_FAILED_TO_RUN",
"createdAt": "2026-03-24T12:00:00.000Z",
"reason": "Task failed to reach RUNNING status: CannotPullContainerError: pull image manifest has been retried 5 time(s)"
}
}
```
### Exemple : événement TASK\$1CREATION\$1FAILED
L'événement suivant montre une tâche daemon qui n'a pas pu être créée sur l'instance de conteneur en raison de ressources CPU insuffisantes. Le `taskArn` champ n'est pas présent car aucune tâche n'a été créée.
```
{
"version": "0",
"id": "87654321-4321-4321-4321-210987654321",
"detail-type": "ECS Daemon Service Action",
"source": "aws.ecs",
"account": "123456789012",
"time": "2026-03-24T12:01:00Z",
"region": "us-west-2",
"resources": [],
"detail": {
"eventType": "WARNING",
"eventName": "DAEMON_TASK_START_IMPAIRED",
"clusterArn": "arn:aws:ecs:us-west-2:123456789012:cluster/my-cluster",
"containerInstanceArn": "arn:aws:ecs:us-west-2:123456789012:container-instance/my-cluster/b2c3d4e5f6a7",
"daemonRevisionArn": "arn:aws:ecs:us-west-2:123456789012:daemon-revision/my-cluster/my-daemon/a1b2c3d4-e5f6-7890-abcd-ef1234567890",
"capacityProviderName": "my-capacity-provider",
"daemonArn": "arn:aws:ecs:us-west-2:123456789012:daemon/my-cluster/my-daemon",
"daemonTaskDefinitionArn": "arn:aws:ecs:us-west-2:123456789012:daemon-task-definition/my-daemon-td:1",
"failureType": "TASK_CREATION_FAILED",
"createdAt": "2026-03-24T12:01:00.000Z",
"reason": "RESOURCE:CPU - Unable to place daemon task on container instance: insufficient CPU"
}
}
```
## Événements de modification de l'état du déploiement du démon
Amazon ECS envoie des événements de changement d'état de déploiement du démon avec le type `ECS Daemon Deployment State Change` de détail. Amazon ECS émet ces événements chaque fois que l'état du déploiement d'un daemon change.
### Types d'événements de changement d'état de déploiement
Amazon ECS classe les événements de changement d'état de déploiement selon les types d'événements suivants :
**Évènements INFO**
+ `DAEMON_DEPLOYMENT_PENDING`- Amazon ECS a lancé un déploiement de daemon.
+ `DAEMON_DEPLOYMENT_IN_PROGRESS`- Amazon ECS a commencé le déploiement et remplace activement les tâches daemon.
+ `DAEMON_DEPLOYMENT_SUCCESSFUL`- Amazon ECS a terminé avec succès le déploiement avec toutes les tâches du démon en cours d'exécution et en bon état.
+ `DAEMON_DEPLOYMENT_STOPPED`- Amazon ECS a arrêté le déploiement. Cela se produit lorsqu'un déploiement a échoué ou a été remplacé par un nouveau déploiement.
+ `DAEMON_DEPLOYMENT_STOP_REQUESTED`- Amazon ECS a arrêté le déploiement et va maintenant commencer à revenir en arrière.
+ `DAEMON_DEPLOYMENT_ROLLBACK_IN_PROGRESS`- Amazon ECS a lancé une annulation en raison d'un échec du déploiement ou du déclenchement d'un disjoncteur.
+ `DAEMON_DEPLOYMENT_ROLLBACK_SUCCESSFUL`- Amazon ECS a terminé avec succès l'annulation du déploiement.
**Événements ERROR**
+ `DAEMON_DEPLOYMENT_ROLLBACK_FAILED`- Amazon ECS n'a pas pu terminer l'annulation du déploiement.
### Exemple : événement en attente de déploiement
L'événement suivant montre un déploiement de daemon initié par Amazon ECS.
```
{
"version": "0",
"id": "3329f79b-3dca-07f8-b1c2-5fe99f0b5e87",
"detail-type": "ECS Daemon Deployment State Change",
"source": "aws.ecs",
"account": "111122223333",
"time": "2026-03-05T15:54:41Z",
"region": "us-west-2",
"resources": [
"arn:aws:ecs:us-west-2:111122223333:daemon/my-cluster/my-daemon"
],
"detail": {
"eventType": "INFO",
"eventName": "DAEMON_DEPLOYMENT_PENDING",
"clusterArn": "arn:aws:ecs:us-west-2:111122223333:cluster/my-cluster",
"daemonArn": "arn:aws:ecs:us-west-2:111122223333:daemon/my-cluster/my-daemon",
"daemonDeploymentArn": "arn:aws:ecs:us-west-2:111122223333:daemon-deployment/my-cluster/my-daemon/0EYSiB0qap8xf0N76FsbE",
"targetDaemonRevisionArn": "arn:aws:ecs:us-west-2:111122223333:daemon-revision/my-cluster/my-daemon/85707969-3732-4b6a-a37d-5cefddd7d7dd",
"updatedAt": "2026-03-05T15:54:41.618059641Z"
}
}
```
## Création de règles pour les événements daemon
Vous pouvez créer des règles pour recevoir des notifications lorsque des événements daemon se produisent. Pour plus d'informations sur la création de règles, consultez la section [Création d'une règle](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-create-rule.html) dans le *guide de EventBridge l'utilisateur Amazon*.
Les exemples de modèles d'événements suivants montrent comment filtrer les événements daemon.
### Exemple : faire correspondre tous les événements d'action du service daemon
```
{
"source": ["aws.ecs"],
"detail-type": ["ECS Daemon Service Action"]
}
```
### Exemple : Correspondre à un type de défaillance spécifique
```
{
"source": ["aws.ecs"],
"detail-type": ["ECS Daemon Service Action"],
"detail": {
"eventName": ["DAEMON_TASK_START_IMPAIRED"],
"failureType": ["TASK_CREATION_FAILED"]
}
}
```
### Exemple : associer des événements pour un cluster spécifique
```
{
"source": ["aws.ecs"],
"detail-type": ["ECS Daemon Service Action"],
"detail": {
"eventName": ["DAEMON_TASK_START_IMPAIRED"],
"clusterArn": ["arn:aws:ecs:us-west-2:123456789012:cluster/my-cluster"]
}
}
```
### Exemple : faire correspondre tous les événements de changement d'état de déploiement
```
{
"source": ["aws.ecs"],
"detail-type": ["ECS Daemon Deployment State Change"]
}
```
# Métriques du démon
Amazon ECS publie des CloudWatch statistiques pour Managed Daemons. Vous pouvez utiliser ces métriques pour suivre l'utilisation du processeur et de la mémoire pour les tâches daemon au sein de votre cluster.
Les métriques Daemon utilisent le même espace de `AWS/ECS` noms que les métriques de service. Amazon ECS distingue les métriques du démon des métriques du service par la valeur de la `ServiceName` dimension, qui utilise le préfixe `daemon:` suivi du nom du démon (par exemple,). `daemon:my-daemon`
## Métriques d'utilisation des démons
Amazon ECS mesure l'utilisation du processeur et de la mémoire du démon en pourcentage des ressources utilisées par les tâches du démon par rapport aux ressources spécifiées dans la définition de la tâche du démon.
CloudWatch fournit les statistiques suivantes pour les métriques d'utilisation des démons :
+ **Moyenne** : utilisation moyenne de toutes les tâches daemon du cluster.
+ **Minimum** : utilisation de la tâche daemon utilisant le moins de ressources.
+ **Maximum** : utilisation de la tâche daemon utilisant le plus de ressources.
### Formules d'utilisation
Amazon ECS calcule la statistique moyenne à l'aide des formules suivantes :
```
(Total CPU units used by daemon tasks) x 100
Daemon CPU utilization = -------------------------------------------------------------------------------
(Total CPU units specified in daemon task definition) x (Number of daemon tasks)
```
```
(Total MiB of memory used by daemon tasks) x 100
Daemon memory utilization = ------------------------------------------------------------------------------------
(Total MiB of memory specified in daemon task definition) x (Number of daemon tasks)
```
Ces formules s'appliquent uniquement à la statistique moyenne. Les statistiques Minimum et Maximum représentent respectivement la tâche individuelle du démon dont l'utilisation des ressources est la plus faible et la plus élevée.
L'agent de conteneur Amazon ECS échantillonne l'utilisation du processeur et de la mémoire pour chaque tâche daemon en cours d'exécution toutes les 20 secondes. Chaque minute, l'agent envoie trois échantillons à Amazon ECS. Amazon ECS agrège les échantillons de toutes les tâches du démon du cluster et publie les valeurs moyenne, minimale et maximale CloudWatch sous forme de pourcentage du total des ressources spécifiées dans la définition de la tâche du démon.
### Exemple : calcul de l'utilisation
La définition d'une tâche daemon spécifie 256 unités de processeur et 512 MiB de mémoire. Le daemon exécute 2 tâches sur 2 instances de conteneur. Une tâche daemon utilise 200 unités de processeur et 400 MiB de mémoire. L'autre utilise 100 unités de processeur et 256 Mio de mémoire. Amazon ECS indique les statistiques suivantes :
+ Utilisation moyenne du processeur : ((200 \$1 100) x 100)/(256 x 2) = 58,6 %
+ Utilisation moyenne de la mémoire : ((400 \$1 256) x 100)/(512 x 2) = 64,1 %
## Afficher les métriques du démon
Vous pouvez consulter les métriques du démon en utilisant le AWS Management Console ou le AWS CLI.
### AWS Management Console
1. Ouvrez la CloudWatch console.
1. Dans le volet de navigation de gauche, choisissez **Metrics**, puis **All metrics**.
1. Choisissez l'espace de **noms AWS/ECS.**
1. Choisissez **ClusterNamela ServiceName** dimension.
1. Filtrez les `ServiceName` valeurs commençant par « `daemon:` pour localiser les métriques de votre démon ».
### AWS CLI
Exécutez la `get-metric-statistics` commande pour récupérer les métriques du CloudWatch démon. Spécifiez la `ServiceName` dimension à l'aide du `daemon:` préfixe.
### Exemple : affichage de l'utilisation du processeur par un démon
La commande suivante permet de récupérer l'utilisation moyenne du processeur pour un démon sur une période de 12 heures avec des intervalles de 5 minutes.
```
aws cloudwatch get-metric-statistics \
--namespace AWS/ECS \
--metric-name CPUUtilization \
--dimensions Name=ClusterName,Value=my-cluster Name=ServiceName,Value=daemon:my-daemon \
--start-time 2026-03-24T00:00:00Z \
--end-time 2026-03-24T12:00:00Z \
--period 300 \
--statistics Average
```
### Exemple : affichage de l'utilisation de la mémoire par un démon
La commande suivante permet de récupérer l'utilisation moyenne de la mémoire d'un démon sur une période de 12 heures avec des intervalles de 5 minutes.
```
aws cloudwatch get-metric-statistics \
--namespace AWS/ECS \
--metric-name MemoryUtilization \
--dimensions Name=ClusterName,Value=my-cluster Name=ServiceName,Value=daemon:my-daemon \
--start-time 2026-03-24T00:00:00Z \
--end-time 2026-03-24T12:00:00Z \
--period 300 \
--statistics Average
```
# Réparation auto Daemon
Amazon ECS considère tous les démons comme essentiels au bon fonctionnement de l'instance. Si une tâche daemon s'arrête ou devient défectueuse, Amazon ECS considère que l'instance est altérée et la vide et la remplace automatiquement. Les actions de réparation auto du démon sont les suivantes :
1. Amazon ECS détecte lorsqu'une tâche daemon s'arrête ou devient défectueuse.
1. Amazon ECS indique que l'instance est épuisée, ce qui l'empêche d'accepter de nouvelles tâches d'application.
1. Amazon ECS fournit une instance de remplacement et lance la tâche daemon sur celle-ci.
1. Une fois que la tâche du démon a atteint un état sain, Amazon ECS planifie les tâches d'application depuis l'instance de vidange jusqu'à l'instance de remplacement.
1. Amazon ECS met fin à l'instance d'origine.
**Important**
Les contrôles de santé des démons sont facultatifs mais vivement recommandés. Sans contrôle de santé, Amazon ECS ne peut détecter les défaillances que lorsque la tâche du démon s'arrête.
Vous pouvez surveiller l'état des démons à l'aide de l'`DescribeContainerInstances`API ou de l'`DescribeTasks`API.