Définir des règles de planification
Cette page a été traduite par PageTurner AI (bêta). Non approuvée officiellement par le projet. Vous avez trouvé une erreur ? Signaler un problème →
Vue d'ensemble de la planification
Ce document explique comment utiliser Chaos Mesh pour créer une tâche planifiée, qui peut générer automatiquement des expériences de chaos à un moment fixe ou à intervalle régulier.
Dans Kubernetes, Chaos Mesh utilise Schedule pour décrire les tâches planifiées.
Le nom d'un objet Schedule ne doit pas dépasser 57 caractères car l'expérience de chaos créée ajoutera 6 caractères aléatoires supplémentaires à la fin du nom. Le nom d'un objet Schedule avec Workflow ne doit pas dépasser 51 caractères car Workflow ajoutera 6 caractères aléatoires supplémentaires à la fin du nom.
Créer des règles de planification avec kubectl via des fichiers YAML
Par exemple, pour appliquer un délai de 100 millisecondes pendant 12 secondes à la cinquième minute de chaque heure, configurez le fichier YAML comme suit :
apiVersion: chaos-mesh.org/v1alpha1
kind: Schedule
metadata:
name: schedule-delay-example
spec:
schedule: '5 * * * *'
historyLimit: 2
concurrencyPolicy: 'Allow'
type: 'NetworkChaos'
networkChaos:
action: delay
mode: one
selector:
namespaces:
- default
labelSelectors:
'app': 'web-show'
delay:
latency: '10ms'
correlation: '100'
jitter: '0ms'
duration: '12s'
Enregistrez ce fichier YAML sous schedule-networkchaos.yaml, puis exécutez kubectl apply -f ./schedule-networkchaos.yaml.
Sur la base de cette configuration, Chaos Mesh créera l'objet NetworkChaos suivant à la cinquième minute de chaque heure (par exemple 0:05, 1:05...) :
apiVersion: chaos-mesh.org/v1alpha1
kind: NetworkChaos
metadata:
name: schedule-delay-example-xxxxx
spec:
action: delay
mode: one
selector:
namespaces:
- default
labelSelectors:
'app': 'web-show'
delay:
latency: '10ms'
correlation: '100'
jitter: '0ms'
duration: '12s'
Les champs de Schedule sont décrits ci-dessous. Ils sont principalement similaires aux champs de CronJob dans Kubernetes. Pour plus d'informations, consultez la documentation Kubernetes CronJob.
Le fuseau horaire du champ schedule correspond à celui du chaos-controller-manager.
Champ schedule
Le champ schedule spécifie l'heure d'exécution d'une expérience. En d'autres termes, un planificateur équivaut à une tâche cron :
# ┌───────────── minute (0 - 59)
# │ ┌───────────── hour (0 - 23)
# │ │ ┌───────────── day of the month (1 - 31)
# │ │ │ ┌───────────── month (1 - 12)
# │ │ │ │ ┌───────────── day of the week (0 - 6) (Sunday to Saturday; 7 is also Sunday on some systems)
# │ │ │ │ │
# │ │ │ │ │
# │ │ │ │ │
# * * * * * <command to execute>
Ce diagramme est extrait de https://en.wikipedia.org/wiki/Cron.
Chaos Mesh utilise robfig/cron/v3 pour transformer le champ schedule en expression cron en interne.
Pour générer une planification, vous pouvez utiliser des outils en ligne comme crontab.guru.
Planifications prédéfinies
En plus de la syntaxe standard, plusieurs planifications prédéfinies sont disponibles. Vous pouvez utiliser ces alternatives aux expressions cron :
| Entry | Description | Equivalent To |
|---|---|---|
| @yearly (or @annually) | Run once a year, midnight, Jan. 1st | 0 0 1 1 * |
| @monthly | Run once a month, midnight, first of month | 0 0 1 * * |
| @weekly | Run once a week, midnight between Sat/Sun | 0 0 * * 0 |
| @daily (or @midnight) | Run once a day, midnight | 0 0 * * * |
| @hourly | Run once an hour, beginning of hour | 0 * * * * |
Ce tableau est extrait de https://pkg.go.dev/github.com/robfig/cron/v3#hdr-Predefined_schedules.
Intervalles
Vous pouvez également planifier une tâche pour qu'elle s'exécute à intervalles fixes, à partir de son ajout ou du lancement de cron. Cela se configure avec la syntaxe suivante :
@every <duration>
Par exemple, @every 1h30m10s indique une planification qui s'active après 1 heure, 30 minutes et 10 secondes, puis à chaque intervalle suivant.
Le contenu sur les Intervals est extrait de https://pkg.go.dev/github.com/robfig/cron/v3#hdr-Intervals. Consultez la documentation officielle pour plus de détails.
Champ historyLimit
Après la fin d'une expérience, son historique n'est pas supprimé pour permettre une récupération et une analyse aisée en cas d'erreurs. La valeur définie dans historyLimit correspond au nombre de tâches conservées, y compris les tâches en cours. Chaos Mesh ne supprime pas les tâches en cours d'exécution.
Lorsque le nombre de tâches dépasse historyLimit, Chaos Mesh supprime séquentiellement les tâches les plus anciennes. Les tâches encore en cours d'exécution sont ignorées et non supprimées.
Champ concurrencyPolicy
Les valeurs disponibles pour ce champ sont "Forbid", "Allow" et "".
Ce champ permet de spécifier si l'objet Schedule peut créer plusieurs expériences simultanées. Par exemple, avec la configuration schedule: * * * * *, une expérience sera créée chaque minute. Si la duration de l'expérience est configurée à 70 secondes, plusieurs expériences seront créées simultanément.
Par défaut, le champ concurrencyPolicy est défini sur Forbid, ce qui interdit la création simultanée de plusieurs expériences. Si vous définissez la valeur du champ concurrencyPolicy sur Allow, plusieurs expériences pourront être créées simultanément.
Prenons l'exemple suivant basé sur une expérience de latence :
spec:
schedule: '* * * * *'
type: 'NetworkChaos'
networkChaos:
action: delay
mode: one
selector:
namespaces:
- default
labelSelectors:
'app': 'web-show'
delay:
latency: '10ms'
duration: '70s'
Avec cette configuration, si vous définissez concurrencyPolicy: "Allow", une latence de 20 millisecondes sera appliquée pendant 10 secondes chaque minute. Pendant les 50 secondes restantes, une latence de 10 millisecondes sera maintenue. Si vous définissez concurrencyPolicy: "Forbid", une latence constante de 10 millisecondes sera toujours présente.
Tous les types d'expériences ne prennent pas en charge plusieurs expériences simultanées sur le même Pod. Pour plus de détails, consultez la documentation spécifique à chaque type d'expérience.
Champ startingDeadlineSeconds
La valeur par défaut de startingDeadlineSeconds est nil.
Lorsque startingDeadlineSeconds est défini sur nil, Chaos Mesh vérifie si des expériences ont été manquées entre la dernière planification et le moment présent (ce qui peut se produire si vous arrêtez Chaos Mesh, suspendez le Schedule longtemps, ou définissez concurrencyPolicy sur Forbid).
Lorsque startingDeadlineSeconds est défini et supérieur à 0, Chaos Mesh vérifie les expériences manquées durant les startingDeadlineSeconds dernières secondes. Si la valeur de startingDeadlineSeconds est trop faible, certaines expériences peuvent être ignorées. Par exemple :
spec:
schedule: '* * * * *'
type: 'NetworkChaos'
networkChaos:
action: delay
mode: one
selector:
namespaces:
- default
labelSelectors:
'app': 'web-show'
startingDeadlineSeconds: 5
delay:
latency: '10ms'
duration: '70s'
Dans cet exemple, la création de nouvelles tâches est interdite au début de chaque minute car concurrencyPolicy est sur Forbid. À la dixième seconde de la minute, l'expérience Chaos précédente s'achève. Mais en raison des contraintes de startingDeadlineSeconds et de concurrencyPolicy, les événements manqués ne sont pas récupérés et aucune expérience n'est créée. Une nouvelle expérience sera uniquement créée au début de la minute suivante.
Si startingDeadlineSeconds n'est pas défini (ou vaut nil), une latence constante de 10 millisecondes sera maintenue. En effet, après l'achèvement de la tâche en cours, Chaos Mesh détecte une tâche manquée (car concurrencyPolicy est défini sur Forbid) et crée immédiatement une nouvelle tâche.
Pour plus d'exemples et d'explications sur ce champ, consultez la documentation Kubernetes CronJob.
Définir les expériences
Pour définir le contenu spécifique d'une expérience, vous devez spécifier deux champs dans Schedule : type et *Chaos. Le champ type indique le type d'expérience, tandis que *Chaos décrit son contenu. Généralement, le champ type utilise la notation UpperCamelCase (ex: NetworkChaos, PodChaos, IOChaos). La clé *Chaos utilise la lowerCamelCase (ex: networkChaos, podChaos, ioChaos). La clé *Chaos correspond au spec du type d'expérience concerné. Pour plus de détails, reportez-vous à la documentation de chaque type d'expérience.
Créer des règles de planification avec Chaos Dashboard
-
Ouvrez Chaos Dashboard et cliquez sur NOUVELLE EXPÉRIENCE pour créer une expérience.
Créer des plans -
Sélectionnez et renseignez les détails spécifiques de l'expérience.
Sélectionnez et renseignez le contenu -
Renseignez les informations incluant le cycle de planification et la stratégie de concurrence.
Renseignez les règles de planification -
Soumettez les informations de l'expérience.
Mettre en pause la tâche planifiée
Contrairement à CronJob, la mise en pause de Schedule empêche non seulement la création d'une nouvelle expérience, mais interrompt également une expérience déjà créée.
Si vous ne souhaitez pas créer d'expérience Chaos en tant que tâche planifiée pour le moment, ajoutez l'annotation experiment.chaos-mesh.org/pause=true à l'objet Schedule. Vous pouvez ajouter cette annotation via la commande kubectl :
kubectl annotate -n $NAMESPACE schedule $NAME experiment.chaos-mesh.org/pause=true
Dans cette commande, $NAMESPACE représente un espace de noms et $NAME le nom de Schedule. Le résultat suivant est retourné en cas de succès :
schedule/$NAME annotated
Pour réactiver la tâche, utilisez cette commande pour supprimer l'annotation :
kubectl annotate -n $NAMESPACE schedule $NAME experiment.chaos-mesh.org/pause-
Dans cette commande, $NAMESPACE représente l'espace de noms et $NAME le nom de Schedule. Le résultat suivant est retourné en cas de succès :
schedule/$NAME annotated