• Le AWS Systems Manager CloudWatch tableau de bord ne sera plus disponible après le 30 avril 2026. Les clients peuvent continuer à utiliser CloudWatch la console Amazon pour consulter, créer et gérer leurs CloudWatch tableaux de bord Amazon, comme ils le font aujourd'hui. Pour plus d'informations, consultez la [documentation Amazon CloudWatch Dashboard](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/CloudWatch_Dashboards.html).
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.
# Créer des runbooks à l'aide de Document Builder
Si les runbooks AWS Systems Manager publics ne prennent pas en charge toutes les actions que vous souhaitez effectuer sur vos AWS ressources, vous pouvez créer vos propres runbooks. Pour créer un runbook personnalisé, vous pouvez créer manuellement un fichier local au format YAML ou JSON contenant les actions d'automatisation appropriées. Vous pouvez également utiliser Document Builder dans la console Systems Manager Automation pour créer un runbook personnalisé.
Grâce à Document Builder, vous pouvez ajouter des actions d'automatisation à votre runbook personnalisé et fournir les paramètres requis, sans utiliser la syntaxe JSON ou YAML. Après avoir ajouté des étapes et créé le runbook, le système convertit les actions que vous avez ajoutées au format YAML que Systems Manager peut utiliser pour exécuter l'automatisation.
Les runbooks prennent en charge l'utilisation de Markdown, un langage de balisage, qui vous permet d'ajouter des descriptions de style wiki aux runbooks et des étapes individuelles au sein du runbook. Pour plus d'informations sur l'utilisation de Markdown, consultez [Utilisation de Markdown dans AWS](https://docs.aws.amazon.com/general/latest/gr/aws-markdown.html).
## Créer un runbook à l'aide de Document Builder
**Avant de commencer**
Nous vous recommandons de prendre connaissance des différentes actions que vous pouvez effectuer dans un runbook. Pour de plus amples informations, veuillez consulter [Référence sur les actions Systems Manager Automation](automation-actions.md).
**Pour créer un runbook à l'aide de Document Builder**
1. Ouvrez la AWS Systems Manager console à l'adresse [https://console.aws.amazon.com/systems-manager/](https://console.aws.amazon.com/systems-manager/).
1. Dans le panneau de navigation, cliquez sur **Documents**.
1. Sélectionnez **Create automation (Créer une automatisation)**.
1. Pour **Name (Nom)**, saisissez un nom descriptif pour le runbook.
1. Pour **Document description (Description du document)**, indiquez la description du style de balisage pour le runbook. Vous pouvez fournir des instructions sur l'utilisation du runbook, des étapes numérotées ou tout autre type d'information pour décrire le runbook. Reportez-vous au texte par défaut pour plus d'informations sur la mise en forme de votre contenu.
**Astuce**
Basculez entre **Hide preview (Masquer l'aperçu)** et **Show preview (Afficher l'aperçu)** pour voir à quoi ressemble le contenu de votre description lors de la composition.
1. (Facultatif) Pour **Assume role (Rôle de responsable)**, entrez le nom ou l'ARN d'un rôle de service qui effectuera des actions en votre nom. Si vous ne spécifiez pas de rôle, Automation utilise les autorisations d'accès de l'utilisateur qui exécute l'automatisation.
**Important**
Pour les runbooks qui ne sont pas la propriété d'Amazon et qui utilisent l'action `aws:executeScript`, un rôle doit être spécifié. Pour plus d'informations, consultez [Autorisations pour l'utilisation de runbooks](automation-document-script-considerations.md#script-permissions).
1. (Facultatif) Pour **Outputs (Sorties)**, saisissez une sortie pour l'automatisation de ce runbook à mettre à disposition d'autres processus.
Par exemple, si votre runbook crée une nouvelle AMI, vous pouvez spécifier [» CreateImage.ImageId «], puis utiliser cette sortie pour créer de nouvelles instances lors d'une automatisation ultérieure.
1. (Facultatif) Développez la section **Input Parameters (Paramètres d'entrée)** et procédez comme suit.
1. Dans **Parameter name (Nom de paramètre)**, saisissez un nom descriptif pour le paramètre de runbook que vous créez.
1. Pour **Type**, sélectionnez un type pour le paramètre, par exemple, `String` ou `MapList`.
1. Pour **Required (Obligatoire)**, effectuez l'une des opérations suivantes :
+ Sélectionnez **Yes (Oui)** si une valeur pour ce paramètre de runbook doit être fournie lors de l'exécution.
+ Sélectionnez **No (Non)** si le paramètre n'est pas obligatoire et (facultatif) saisissez une valeur de paramètre par défaut dans **Defaults value (Valeur par défaut)**.
1. Dans **Description**, saisissez une description pour le paramètre de runbook.
**Note**
Pour ajouter d'autres paramètres de runbook, sélectionnez **Add a parameter (Ajouter un paramètre)**. Pour supprimer un paramètre de runbook, cliquez sur le bouton **X** (Supprimer).
1. (Facultatif) Développez la section **Target type (Type de cible)** et sélectionnez un type de cible pour définir les types de ressources sur lesquelles l'automatisation peut s'exécuter. Par exemple, pour exécuter un runbook sur des instance EC2, sélectionnez `/AWS::EC2::Instance`.
**Note**
Si vous spécifiez la valeur « `/` », le runbook peut s'exécuter sur tous les types de ressources. Pour obtenir la liste des types de ressources valides, consultez la [Référence des types de ressources AWS](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-template-resource-type-ref.html) dans le *Guide de l'utilisateur AWS CloudFormation *.
1. (Facultatif) Développez la section **Document tags (Balises de document)** et saisissez une ou plusieurs paires clé-valeur de balise à appliquer au runbook. Les balises facilitent l'identification, l'organisation et la recherche de ressources.
1. Dans la section **Step 1 (Étape 1)** fournissez les informations suivantes.
+ Pour **Step name (Nom de l'étape)**, entrez un nom descriptif pour la première étape de l'automatisation.
+ Pour **Action type (Type d'action)**, sélectionnez le type d'action à utiliser pour cette étape.
Pour obtenir une liste et des informations sur les types d'action disponibles, consultez [Référence sur les actions Systems Manager Automation](automation-actions.md).
+ Dans **Description**, entrez une description pour l'étape d'automatisation. Vous pouvez utiliser Markdown pour mettre en forme votre texte.
+ Selon le **Type d'action** sélectionné, saisissez les entrées requises pour le type d'action dans la section **Step inputs (Entrées d'étape)**. Par exemple, si vous avez sélectionné l'action `aws:approve`, vous devez spécifier une valeur pour la propriété `Approvers`.
Pour plus d'informations sur les champs d'entrée d'étape, consultez l'entrée de [Référence sur les actions Systems Manager Automation](automation-actions.md) correspondant au type d'action sélectionné. Par exemple : [`aws:executeStateMachine`— Lance une machine à AWS Step Functions états](automation-action-executeStateMachine.md).
+ (Facultatif) Pour **Additional inputs (entrées supplémentaires)**, indiquez toutes les valeurs d'entrée supplémentaires nécessaires à votre runbook. Les types d'entrée disponibles dépendent du type d'action que vous avez sélectionné pour l'étape. (Notez que certains types d'action nécessitent des valeurs d'entrée.)
**Note**
Pour ajouter d'autres entrées, sélectionnez **Add optional input (Ajouter une entrée facultative)**. Pour supprimer une entrée, cliquez sur le bouton **X** (Supprimer).
+ (Facultatif) Pour **Outputs (Sorties)**, saisissez une sortie pour cette étape à mettre à disposition d'autres processus.
**Note**
L'option **Outputs (Sorties)** n'est pas disponible pour tous les types d'action.
+ (Facultatif) Développez la section **Common properties (Propriétés communes)** et spécifiez les propriétés des actions communes à toutes les actions d'automatisation. Par exemple, pour **Timeout seconds (Expiration en secondes)**, vous pouvez fournir une valeur en secondes pour spécifier la durée de l'exécution de l'étape avant qu'elle ne soit arrêtée.
Pour de plus amples informations, veuillez consulter [Propriétés partagées par toutes les actions](automation-actions.md#automation-common).
**Note**
Pour ajouter d'autres étapes, sélectionnez **Add step (Ajouter étape)** et répétez la procédure de création d'une étape. Pour supprimer une étape, sélectionnez **Remove step (Supprimer étape)**.
1. Sélectionnez **Create automation (Créer une automatisation)** pour enregistrer le runbook.
## Créer un runbook qui exécute des scripts
La procédure suivante explique comment utiliser Document Builder dans la console AWS Systems Manager Automation pour créer un runbook personnalisé qui exécute un script.
La première étape du runbook que vous créez exécute un script pour lancer une instance Amazon Elastic Compute Cloud (Amazon EC2). La deuxième étape exécute un autre script pour surveiller la vérification de l'état de l'instance à remplacer par `ok`. Ensuite, un état général de `Success` est signalé pour l'automatisation.
**Avant de commencer**
Assurez-vous que vous avez suivi les étapes ci-dessous :
+ Vérifiez que vous disposez de privilèges d'administrateur ou que vous avez obtenu les autorisations adéquates d'accès à Systems Manager dans Gestion des identités et des accès AWS (IAM).
Pour plus d'informations, consultez [Vérification de l'accès utilisateur aux runbooks](automation-setup.md#automation-setup-user-access).
+ Vérifiez que vous disposez d'un rôle de service IAM pour Automation (également appelé *rôle de responsable*) dans votre Compte AWS. Ce rôle est obligatoire car cette procédure utilise l'action `aws:executeScript`.
Pour en savoir plus sur la création de ce rôle, consultez [Configuration d'un accès à un rôle de service (rôle de responsable) pour les automatisations](automation-setup.md#automation-setup-configure-role).
Pour plus d'informations sur le rôle de service IAM requis pour exécuter `aws:executeScript`, consultez [Autorisations pour l'utilisation de runbooks](automation-document-script-considerations.md#script-permissions).
+ Vérifiez que vous avez l'autorisation de lancer des instances EC2.
Pour plus d’informations, consultez [IAM et Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/UsingIAM.html#intro-to-iam) dans le *Guide de l’utilisateur Amazon EC2*.
**Créer un runbook personnalisé qui exécute des scripts à l'aide de Document Builder**
1. Ouvrez la AWS Systems Manager console à l'adresse [https://console.aws.amazon.com/systems-manager/](https://console.aws.amazon.com/systems-manager/).
1. Dans le panneau de navigation, cliquez sur **Documents**.
1. Sélectionnez **Create automation (Créer une automatisation)**.
1. Dans **Name (Nom)**, saisissez ce nom descriptif pour le runbook : **LaunchInstanceAndCheckStatus**.
1. (Facultatif) Pour **Document description (Description du document)**, remplacez le texte par défaut par une description pour ce runbook, à l'aide de Markdown. Voici un exemple.
```
##Title: LaunchInstanceAndCheckState
-----
**Purpose**: This runbook first launches an EC2 instance using the AMI ID provided in the parameter ```imageId```. The second step of this runbook continuously checks the instance status check value for the launched instance until the status ```ok``` is returned.
##Parameters:
-----
Name | Type | Description | Default Value
------------- | ------------- | ------------- | -------------
assumeRole | String | (Optional) The ARN of the role that allows Automation to perform the actions on your behalf. | -
imageId | String | (Optional) The AMI ID to use for launching the instance. The default value uses the latest Amazon Linux 2023 AMI ID available. | {{ ssm:/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-6.1-arm64 }}
```
1. Pour **Assume role (Rôle de responsable)**, saisissez l'ARN du rôle de service IAM pour Automation (rôle de responsable) pour l'exécution de l'automatisation, au format **arn:aws:iam::111122223333:role/AutomationServiceRole**. Remplacez votre Compte AWS identifiant par 111122223333.
Le rôle que vous spécifiez est utilisé pour fournir les autorisations nécessaires pour démarrer l'automatisation.
**Important**
Pour les runbooks qui ne sont pas la propriété d'Amazon et qui utilisent l'action `aws:executeScript`, un rôle doit être spécifié. Pour plus d'informations, consultez [Autorisations pour l'utilisation de runbooks](automation-document-script-considerations.md#script-permissions).
1. Développez **Input parameters (Paramètres d'entrée)** et procédez comme suit.
1. Dans **Parameter name (Nom du paramètre)**, entrez **imageId**.
1. Dans le champ **Type**, sélectionnez **String**.
1. Pour **Required (Obligatoire)**, sélectionnez `No`.
1. Pour **Default value (Valeur par défaut)**, entrez ce qui suit.
```
{{ ssm:/aws/service/ami-amazon-linux-latest/al2023-ami-kernel-6.1-arm64 }}
```
**Note**
Cette valeur lance une instance Amazon EC2 à l’aide du dernier ID d’Amazon Machine Image (AMI) Amazon Linux 2023. Si vous souhaitez utiliser une autre AMI, remplacez la valeur par l'ID de votre AMI.
1. Pour **Description**, entrez ce qui suit.
```
(Optional) The AMI ID to use for launching the instance. The default value uses the latest released Amazon Linux 2023 AMI ID.
```
1. Sélectionnez **Add a parameter (Ajouter un paramètre)** pour créer le second paramètre **tagValue**, puis entrez ce qui suit.
1. Dans **Parameter name (Nom du paramètre)**, entrez **tagValue**.
1. Dans le champ **Type**, sélectionnez **String**.
1. Pour **Required (Obligatoire)**, sélectionnez `No`.
1. Pour **Default value (Valeur par défaut)**, entrez **LaunchedBySsmAutomation**. La paire clé-valeur de balise `Name:LaunchedBySsmAutomation` est ajoutée à l'instance.
1. Pour **Description**, entrez ce qui suit.
```
(Optional) The tag value to add to the instance. The default value is LaunchedBySsmAutomation.
```
1. Sélectionnez **Add a parameter (Ajouter un paramètre)** pour créer le troisième paramètre **instanceType**, puis entrez les informations suivantes.
1. Dans **Parameter name (Nom du paramètre)**, entrez **instanceType**.
1. Dans le champ **Type**, sélectionnez **String**.
1. Pour **Required (Obligatoire)**, sélectionnez `No`.
1. Pour **Default value (Valeur par défaut)**, entrez **t2.micro**.
1. Pour **Parameter description (Description du paramètre)**, entrez ce qui suit.
```
(Optional) The instance type to use for the instance. The default value is t2.micro.
```
1. Développez **Target type (Type de cible)** et sélectionnez **"/"**.
1. (Facultatif) Développez les **Document tags (Balises de document)** pour appliquer des balises de ressources à votre runbook. Pour la **Tag key (Clé de balise)**, entrez **Purpose**, et pour **Tag value (Valeur de balise)**, entrez **LaunchInstanceAndCheckState**.
1. Dans la section **Step 1 (Étape 1)** procédez comme suit.
1. Pour **Step name (Nom de l'étape)**, entrez un nom descriptif pour la première étape de l'automatisation : **LaunchEc2Instance**.
1. Pour **Action type (Type d'action)**, sélectionnez **Run a script (Exécuter un script=** (**aws:executeScript**).
1. Dans **Description**, entrez une description de l'étape d'automatisation, telle que la suivante.
```
**About This Step**
This step first launches an EC2 instance using the ```aws:executeScript``` action and the provided script.
```
1. Développez **Inputs (Entrées)**.
1. Dans **Runtime**, sélectionnez le langage d'exécution à utiliser pour exécuter le script fourni.
1. Pour **Handler** (Gestionnaire), entrez **launch\_instance**. Il s'agit du nom de la fonction déclaré dans le script suivant.
**Note**
Cela n'est pas obligatoire pour PowerShell.
1. Pour **Script**, remplacez le contenu par défaut par ce qui suit. Veillez à faire correspondre le script avec la valeur d'exécution correspondante.
------
#### [ Python ]
```
def launch_instance(events, context):
import boto3
ec2 = boto3.client('ec2')
image_id = events['image_id']
tag_value = events['tag_value']
instance_type = events['instance_type']
tag_config = {'ResourceType': 'instance', 'Tags': [{'Key':'Name', 'Value':tag_value}]}
res = ec2.run_instances(ImageId=image_id, InstanceType=instance_type, MaxCount=1, MinCount=1, TagSpecifications=[tag_config])
instance_id = res['Instances'][0]['InstanceId']
print('[INFO] 1 EC2 instance is successfully launched', instance_id)
return { 'InstanceId' : instance_id }
```
------
#### [ PowerShell ]
```
Install-Module AWS.Tools.EC2 -Force
Import-Module AWS.Tools.EC2
$payload = $env:InputPayload | ConvertFrom-Json
$imageid = $payload.image_id
$tagvalue = $payload.tag_value
$instanceType = $payload.instance_type
$type = New-Object Amazon.EC2.InstanceType -ArgumentList $instanceType
$resource = New-Object Amazon.EC2.ResourceType -ArgumentList 'instance'
$tag = @{Key='Name';Value=$tagValue}
$tagSpecs = New-Object Amazon.EC2.Model.TagSpecification
$tagSpecs.ResourceType = $resource
$tagSpecs.Tags.Add($tag)
$res = New-EC2Instance -ImageId $imageId -MinCount 1 -MaxCount 1 -InstanceType $type -TagSpecification $tagSpecs
return @{'InstanceId'=$res.Instances.InstanceId}
```
------
1. Développer **Additional inputs (Entrées supplémentaires)**.
1. Dans **Nom de l'entrée**, choisissez **InputPayload**. Pour **Input value (Valeur d'entrée)**, entrez les données YAML suivantes.
```
image_id: "{{ imageId }}"
tag_value: "{{ tagValue }}"
instance_type: "{{ instanceType }}"
```
1. Développez **Outputs (Sorties)** et procédez comme suit :
+ Pour **Nom**, saisissez **payload**.
+ Pour **Selector (Sélecteur)**, entrez **$.Payload**.
+ Dans le champ **Type**, sélectionnez `StringMap`.
1. Sélectionnez **Add step (Ajouter une étape)** pour ajouter une deuxième étape au runbook. La deuxième étape interroge l'état de l'instance lancée à l'étape 1 et attend que l'état renvoyé soit `ok`.
1. Dans la section **Step 2 (Étape 2)** procédez comme suit.
1. Pour **Step name (Nom de l'étape)**, entrez un nom descriptif pour la deuxième étape de l'automatisation : **WaitForInstanceStatusOk**.
1. Pour **Action type (Type d'action)**, sélectionnez **Run a script (Exécuter un script=** (**aws:executeScript**).
1. Dans **Description**, entrez une description de l'étape d'automatisation, telle que la suivante.
```
**About This Step**
The script continuously polls the instance status check value for the instance launched in Step 1 until the ```ok``` status is returned.
```
1. Pour **Exécution**, sélectionnez le langage d'exécution à utiliser pour exécuter le script fourni.
1. Pour **Handler** (Gestionnaire), entrez **poll\_instance**. Il s'agit du nom de la fonction déclaré dans le script suivant.
**Note**
Cela n'est pas obligatoire pour PowerShell.
1. Pour **Script**, remplacez le contenu par défaut par ce qui suit. Veillez à faire correspondre le script avec la valeur d'exécution correspondante.
------
#### [ Python ]
```
def poll_instance(events, context):
import boto3
import time
ec2 = boto3.client('ec2')
instance_id = events['InstanceId']
print('[INFO] Waiting for instance status check to report ok', instance_id)
instance_status = "null"
while True:
res = ec2.describe_instance_status(InstanceIds=[instance_id])
if len(res['InstanceStatuses']) == 0:
print("Instance status information is not available yet")
time.sleep(5)
continue
instance_status = res['InstanceStatuses'][0]['InstanceStatus']['Status']
print('[INFO] Polling to get status of the instance', instance_status)
if instance_status == 'ok':
break
time.sleep(10)
return {'Status': instance_status, 'InstanceId': instance_id}
```
------
#### [ PowerShell ]
```
Install-Module AWS.Tools.EC2 -Force
$inputPayload = $env:InputPayload | ConvertFrom-Json
$instanceId = $inputPayload.payload.InstanceId
$status = Get-EC2InstanceStatus -InstanceId $instanceId
while ($status.Status.Status -ne 'ok'){
Write-Host 'Polling get status of the instance', $instanceId
Start-Sleep -Seconds 5
$status = Get-EC2InstanceStatus -InstanceId $instanceId
}
return @{Status = $status.Status.Status; InstanceId = $instanceId}
```
------
1. Développer **Additional inputs (Entrées supplémentaires)**.
1. Dans **Nom de l'entrée**, choisissez **InputPayload**. Pour **Input value (Valeur d'entrée)**, entrez ce qui suit.
```
{{ LaunchEc2Instance.payload }}
```
1. Sélectionnez **Create automation (Créer une automatisation)** pour enregistrer le runbook.