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.
# AWS Config Règles personnalisées
AWS Config Les règles personnalisées sont des règles que vous créez de toutes pièces. Il existe deux manières de créer des règles AWS Config personnalisées : avec les fonctions Lambda ([Guide du AWS Lambda développeur](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html#gettingstarted-concepts-function)) et avec Guard ([Guard GitHub Repository](https://github.com/aws-cloudformation/cloudformation-guard)), un policy-as-code langage.
AWS Config *les règles personnalisées créées avec Lambda sont appelées règles *AWS Config Lambda AWS Config personnalisées et les règles* personnalisées créées avec Guard sont appelées AWS Config règles de politique personnalisées.*
Avant d'utiliser des règles personnalisées, consultez[Considérations](evaluate-config.md#evaluate-config-considerations).
## AWS Config Règles de politique personnalisées
Les règles écrites à l'aide de Guard peuvent être créées à partir de la AWS Config console ou à l'aide de la AWS Config règle APIs. AWS Config Les règles de politique personnalisées vous permettent de créer des règles AWS Config personnalisées sans avoir à utiliser Java ou Python pour développer des fonctions Lambda afin de gérer vos règles personnalisées. AWS Config Les règles de politique personnalisées sont initiées par des modifications de configuration. Pour plus d'informations sur Guard, consultez le [ GitHubréférentiel Guard](https://github.com/aws-cloudformation/cloudformation-guard).
## AWS Config Règles Lambda personnalisées
Les règles Lambda personnalisées vous permettent d'utiliser Java ou Python pour créer une fonction Lambda pour une règle personnalisée. AWS Config Une *fonction Lambda* est un code personnalisé que vous téléchargez et qui est invoqué par des événements qui y sont publiés par une source d'événements. AWS Lambda Si la fonction Lambda est associée à une AWS Config règle, elle l' AWS Config invoque lorsque la règle est initiée. La fonction Lambda évalue ensuite les informations de configuration envoyées par et renvoie AWS Config les résultats de l'évaluation. Pour plus d'informations sur les fonctions Lambda, consultez [Fonction et sources d'événements](https://docs.aws.amazon.com/lambda/latest/dg/intro-core-components.html) dans le *Guide du développeur AWS Lambda *.
## Différences de format pour les règles AWS Config personnalisées
Le tableau suivant présente les différences de format entre les champs pour le type de [ConfigurationItem](https://docs.aws.amazon.com/config/latest/APIReference/API_ConfigurationItem.html)données et pour les règles AWS Config personnalisées.
| ConfigurationItem | AWS Config Règle personnalisée |
| --- | --- |
| version | configurationItemVersion |
| accountId | awsAccountId |
| arn | ARN |
| configurationItemMD5Hash | configurationStateMd5Hash |
**Topics**
+ [Règles de politiques personnalisées](#evaluate-config_develop-rules-policy)
+ [Règles Lambda personnalisées](#evaluate-config_develop-rules-lambda)
+ [Différences de format pour les règles AWS Config personnalisées](#evaluate-config_develop-schema)
+ [Création de règles de politiques personnalisées](evaluate-config_develop-rules_cfn-guard.md)
+ [Création de règles Lambda personnalisées](evaluate-config_develop-rules_lambda-functions.md)
+ [Gestion des ressources supprimées pour les règles Lambda personnalisées](evaluate-config_develop-rules-delete.md)
# Création de règles de politique AWS Config personnalisées
Vous pouvez créer des règles de politique AWS Config personnalisées à partir de l' AWS Config API AWS Management Console AWS CLI, ou.
## Ajouter AWS Config des règles de politique personnalisées
------
#### [ Using the console ]
1. Connectez-vous à la AWS Config console AWS Management Console et ouvrez-la à la [https://console.aws.amazon.com/config/maison](https://console.aws.amazon.com/config/home).
1. Dans le AWS Management Console menu, vérifiez que le sélecteur de région est défini sur une AWS région qui prend en charge les AWS Config règles. Pour obtenir la liste des régions prises en charge, consultez [Régions et points de terminaison AWS Config](https://docs.aws.amazon.com/general/latest/gr/awsconfig.html) dans le *Référence générale d'Amazon Web Services*.
1. Dans le volet de navigation de gauche, choisissez **Règles**.
1. Sur la page **Règles**, choisissez **Ajouter une règle**.
1. Sur la page **Spécifier le type de règle**, choisissez **Créer une règle personnalisée à l'aide de Guard**.
1. Sur la page **Configurer une règle**, créez la règle en réalisant les étapes suivantes :
1. Saisissez un nom unique dans le champ **Nom de la règle**.
1. Saisissez une description de la règle dans le champ **Description**.
1. Pour la **version d'exécution de Guard**, choisissez le système d'exécution pour votre règle de politique AWS Config personnalisée.
1. Vous pouvez renseigner le **Contenu de la règle** avec la politique Guard personnalisée correspondant à votre règle.
1. Pour le **mode d'évaluation**, choisissez à quel moment du processus de création et de gestion des ressources vous AWS Config souhaitez évaluer vos ressources. Selon la règle, AWS Config vous pouvez évaluer vos configurations de ressources avant qu'une ressource ne soit provisionnée, après qu'une ressource ait été provisionnée, ou les deux.
1. Choisissez **Activer l'évaluation proactive** pour évaluer les paramètres de configuration de vos ressources avant leur déploiement.
Après avoir activé l'évaluation proactive, vous pouvez utiliser l'[StartResourceEvaluation](https://docs.aws.amazon.com/config/latest/APIReference/API_StartResourceEvaluation.html)API et l'[GetResourceEvaluationSummary](https://docs.aws.amazon.com/config/latest/APIReference/API_GetResourceEvaluationSummary.html)API pour vérifier si les ressources que vous spécifiez dans ces commandes seront signalées comme NON CONFORMES par les règles proactives de votre compte dans votre région.
Pour plus d'informations sur l'utilisation de ces commandes, consultez la section [Évaluation de vos ressources à l'aide de AWS Config règles](https://docs.aws.amazon.com/config/latest/developerguide/evaluating-your-resources.html#evaluating-your-resources-proactive). Pour obtenir la liste des règles gérées qui prennent en charge l'évaluation proactive, consultez la section [Liste des règles AWS Config gérées par mode d'évaluation](https://docs.aws.amazon.com/config/latest/developerguide/managed-rules-by-evaluation-mode.html).
1. Choisissez **Activer l'évaluation détective** pour évaluer les paramètres de configuration de vos ressources existantes.
À des fins d'évaluation préventive, les règles de politique AWS Config personnalisée sont initiées par les **modifications de configuration**. Cette option sera présélectionnée.
+ **Ressources** : lorsqu'une ressource qui correspond au type de ressource spécifié, ou au type plus à l'identifiant, est créée, modifiée ou supprimée.
+ **Balises** : lorsqu'une ressource portant la balise spécifiée est créée, modifiée ou supprimée.
+ **Toutes les modifications** : lorsqu'une ressource enregistrée par AWS Config est créée, modifiée ou supprimée.
AWS Config exécute l'évaluation lorsqu'il détecte une modification apportée à une ressource correspondant au champ d'application de la règle. Vous pouvez utiliser la portée afin de limiter les ressources qui déclenchent des évaluations. Dans le cas contraire, les évaluations sont lancées en cas de modification d'une ressource post-provisionnée.
1. Vous pouvez personnaliser les valeurs des clés fournies dans le champ **Paramètres**, si votre règle comprend des paramètres. Un paramètre est un attribut que vos ressources doivent respecter pour pouvoir être considérées conformes à la règle.
1. Sur la page **Réviser et créer**, passez en revue toutes vos sélections avant d'ajouter la règle à votre Compte AWS.
1. Lorsque vous avez vérifié vos règles, choisissez **Ajouter une règle**.
------
#### [ Using the AWS CLI ]
Utilisez la commande [https://docs.aws.amazon.com/cli/latest/reference/configservice/put-config-rule.html](https://docs.aws.amazon.com/cli/latest/reference/configservice/put-config-rule.html).
Le champ `Owner` doit présenter la valeur `CUSTOM_POLICY`. Les champs supplémentaires suivants sont obligatoires pour les règles de politique AWS Config personnalisée :
+ `Runtime`: le système d'exécution de vos règles de politique AWS Config personnalisée.
+ `PolicyText` : la définition de la politique contenant la logique de vos règles de politiques AWS Config personnalisées.
+ `EnableDebugLogDelivery`: expression booléenne permettant d'activer la journalisation du débogage pour votre règle de politique AWS Config personnalisée. La valeur par défaut est `false`.
------
#### [ Using the API Reference ]
Utilisez l'action [PutConfigRule](https://docs.aws.amazon.com/config/latest/APIReference/API_PutConfigRule.html).
Le champ `Owner` doit présenter la valeur `CUSTOM_POLICY`. Les champs supplémentaires suivants sont obligatoires pour les règles de politique AWS Config personnalisée :
+ `Runtime`: le système d'exécution de vos règles de politique AWS Config personnalisée.
+ `PolicyText` : la définition de la politique contenant la logique de vos règles de politiques AWS Config personnalisées.
+ `EnableDebugLogDelivery`: expression booléenne permettant d'activer la journalisation du débogage pour votre règle de politique AWS Config personnalisée. La valeur par défaut est `false`.
------
## Rédaction du contenu des règles pour les règles de politique AWS Config personnalisées
Avec les règles de politique AWS Config personnalisées, vous pouvez utiliser le langage spécifique au domaine (DSL) de AWS CloudFormation Guard pour évaluer les configurations des ressources. Cette rubrique fournit des modèles et des bonnes pratiques pour la rédaction de règles de politique personnalisées.
Pour plus d'informations sur la façon d'écrire des règles avec Guard, consultez la section [Writing Guard](https://docs.aws.amazon.com/cfn-guard/latest/ug/writing-rules.html) dans le AWS CloudFormation guide de l'utilisateur de [AWS CloudFormation Guard et les modes de fonctionnement de Guard 2.0](https://github.com/aws-cloudformation/cloudformation-guard/tree/main/guard) dans le GitHub référentiel Guard.
### Structure des règles de base
Utilisez le format de base suivant pour créer des règles :
```
# Basic rule format
rule when
resourceType == "" {
# Evaluation clauses
}
# Example with filtering
let resources_of_type = Resources.*[ Type == 'AWS::Service::Resource' ]
rule check_resources when %resources_of_type !empty {
%resources_of_type.configuration.property == expected_value
}
```
### Composants clés
configuration
Contient le contenu de la configuration des ressources.
supplementaryConfiguration
Contient du contenu supplémentaire pour la configuration des ressources. AWS Config renvoie ce champ pour certains types de ressources afin de compléter les informations renvoyées pour le champ de configuration.
resourceType
AWS type de ressource en cours d'évaluation.
resourceId
L'ID de la ressource (par exemple,`sg-xxxxxx`).
accountId
L' Compte AWS identifiant à 12 chiffres associé à la ressource.
### Schémas courants
------
#### [ Status checks ]
```
let allowed_status = ['ACTIVE', 'RUNNING']
rule check_resource_status when
resourceType == "AWS::Service::Resource" {
configuration.status IN %allowed_status
}
```
------
#### [ Required properties ]
```
rule check_required_properties when
resourceType == "AWS::Service::Resource" {
configuration.propertyName exists
configuration.propertyName is_string # or is_list, is_struct
}
```
------
#### [ Query blocks ]
```
configuration.Properties {
property1 exists
property2 is_string
property3 IN [allowed_value1, allowed_value2]
}
```
------
#### [ Conditional evaluation ]
```
when configuration.feature_enabled == true {
configuration.feature_settings exists
configuration.feature_settings is_struct
}
```
------
#### [ Custom messages ]
```
rule check_compliance when
resourceType == "AWS::Service::Resource" {
configuration.property == expected_value <>
}}
```
------
### Fonctionnalités avancées
------
#### [ Range checks ]
```
rule check_numeric_limits {
# Inclusive range (lower_limit <= value <= upper_limit)
configuration.value IN r[minimum_value, maximum_value]
# Exclusive range (lower_limit < value < upper_limit)
configuration.value IN r(exclusive_min, exclusive_max)
# Left inclusive, right exclusive (lower_limit <= value < upper_limit)
configuration.value IN r[minimum_value, exclusive_max)
# Left exclusive, right inclusive (lower_limit < value <= upper_limit)
configuration.value IN r(exclusive_min, maximum_value]
}
```
------
#### [ Combining conditions ]
```
# AND conditions (implicit through new lines)
condition_1
condition_2
# OR conditions (explicit)
condition_3 OR
condition_4
```
------
#### [ Chaining rules ]
```
rule check_prerequisites {
configuration.required_setting exists
}
rule check_details when check_prerequisites {
configuration.required_setting == expected_value
}
```
------
### Bonnes pratiques
+ Utilisez des variables avec des `let` instructions pour une meilleure lisibilité.
+ Regroupez les vérifications associées à l'aide de blocs de règles nommés.
+ Incluez des commentaires descriptifs.
+ Utilisez les opérateurs appropriés (`exists`,`is_string`,`is_list`).
+ Utilisez des modèles regex avec une correspondance insensible aux majuscules et minuscules.
### Exemple : dynamodb-pitr-enabled
L'exemple suivant montre la définition de politique pour une version de règle de politique AWS Config personnalisée de la règle AWS Config gérée[dynamodb-pitr-enabled](dynamodb-pitr-enabled.md). Cette règle vérifie si la restauration est activée pour les tables Point-in-Time DynamoDB.
```
# Check if DynamoDB tables have Point-in-Time Recovery enabled
let status = ['ACTIVE']
rule tableisactive when
resourceType == "AWS::DynamoDB::Table" {
configuration.tableStatus == %status
}
rule checkcompliance when
resourceType == "AWS::DynamoDB::Table"
tableisactive {
let pitr = supplementaryConfiguration.ContinuousBackupsDescription.pointInTimeRecoveryDescription.pointInTimeRecoveryStatus
%pitr == "ENABLED" <>
}
```
# Création de AWS Config règles Lambda personnalisées
Vous pouvez développer des règles personnalisées et les ajouter à l' AWS Config aide de AWS Lambda fonctions.
Vous associez chaque règle personnalisée à une fonction Lambda, qui contient la logique qui évalue si vos AWS ressources sont conformes à la règle. Vous associez cette fonction à votre règle qui invoque la fonction soit en réponse aux changements de configuration, soit de façon périodique. La fonction évalue ensuite si vos ressources sont conformes à votre règle et envoie les résultats de son évaluation à AWS Config.
## AWS Kit de développement de règles (RDK)
Le kit de développement de AWS règles (RDK) est conçu pour prendre en charge un flux de travail de « conformité en tant que code » intuitif et productif. Il élimine une grande partie de la charge de travail indifférenciée associée au déploiement de AWS Config règles soutenues par des fonctions Lambda personnalisées et fournit un processus itératif rationalisé. develop-deploy-monitor
Pour obtenir des step-by-step instructions, consultez la [documentation du kit de développement de AWS règles (RDK)](https://aws-config-rdk.readthedocs.io/en/master).
## Exemples de AWS Lambda fonctions pour AWS Config les règles (Node.js)
AWS Lambda exécute des fonctions en réponse à des événements publiés par les AWS services. La fonction d'une règle Lambda AWS Config personnalisée reçoit un événement publié par AWS Config, puis utilise les données qu'elle reçoit de l'événement et qu'elle extrait de l' AWS Config API pour évaluer la conformité de la règle. Les opérations dans une fonction pour une règle de configuration varient selon qu'il s'agisse d'une évaluation déclenchée par des changements de configuration ou de façon périodique.
Pour plus d'informations sur les modèles courants au sein des AWS Lambda fonctions, voir [Modèle de programmation](https://docs.aws.amazon.com/lambda/latest/dg/programming-model-v2.html) dans le *Guide du AWS Lambda développeur*.
------
#### [ Example Function for Evaluations Triggered by Configuration Changes ]
AWS Config invoquera une fonction comme dans l'exemple suivant lorsqu'elle détecte un changement de configuration pour une ressource comprise dans le champ d'application d'une règle personnalisée.
Si vous utilisez la AWS Config console pour créer une règle associée à une fonction comme dans cet exemple, choisissez **Configuration changes** comme type de déclencheur. Si vous utilisez l' AWS Config API ou AWS CLI pour créer la règle, définissez l'`MessageType`attribut sur `ConfigurationItemChangeNotification` et`OversizedConfigurationItemChangeNotification`. Ces paramètres permettent à votre règle d'être déclenchée chaque fois qu'un élément de configuration ou un élément de configuration surdimensionné est AWS Config généré à la suite d'un changement de ressource.
Cet exemple évalue vos ressources et vérifie si les instances correspondent au type de ressource, `AWS::EC2::Instance`. La règle est déclenchée quand AWS Config génère un élément de configuration ou une notification d'élément de configuration surdimensionné.
```
'use strict';
import { ConfigServiceClient, GetResourceConfigHistoryCommand, PutEvaluationsCommand } from "@aws-sdk/client-config-service";
const configClient = new ConfigServiceClient({});
// Helper function used to validate input
function checkDefined(reference, referenceName) {
if (!reference) {
throw new Error(`Error: ${referenceName} is not defined`);
}
return reference;
}
// Check whether the message type is OversizedConfigurationItemChangeNotification,
function isOverSizedChangeNotification(messageType) {
checkDefined(messageType, 'messageType');
return messageType === 'OversizedConfigurationItemChangeNotification';
}
// Get the configurationItem for the resource using the getResourceConfigHistory API.
async function getConfiguration(resourceType, resourceId, configurationCaptureTime, callback) {
const input = { resourceType, resourceId, laterTime: new Date(configurationCaptureTime), limit: 1 };
const command = new GetResourceConfigHistoryCommand(input);
await configClient.send(command).then(
(data) => {
callback(null, data.configurationItems[0]);
},
(error) => {
callback(error, null);
}
);
}
// Convert the oversized configuration item from the API model to the original invocation model.
function convertApiConfiguration(apiConfiguration) {
apiConfiguration.awsAccountId = apiConfiguration.accountId;
apiConfiguration.ARN = apiConfiguration.arn;
apiConfiguration.configurationStateMd5Hash = apiConfiguration.configurationItemMD5Hash;
apiConfiguration.configurationItemVersion = apiConfiguration.version;
apiConfiguration.configuration = JSON.parse(apiConfiguration.configuration);
if ({}.hasOwnProperty.call(apiConfiguration, 'relationships')) {
for (let i = 0; i < apiConfiguration.relationships.length; i++) {
apiConfiguration.relationships[i].name = apiConfiguration.relationships[i].relationshipName;
}
}
return apiConfiguration;
}
// Based on the message type, get the configuration item either from the configurationItem object in the invoking event or with the getResourceConfigHistory API in the getConfiguration function.
async function getConfigurationItem(invokingEvent, callback) {
checkDefined(invokingEvent, 'invokingEvent');
if (isOverSizedChangeNotification(invokingEvent.messageType)) {
const configurationItemSummary = checkDefined(invokingEvent.configurationItemSummary, 'configurationItemSummary');
await getConfiguration(configurationItemSummary.resourceType, configurationItemSummary.resourceId, configurationItemSummary.configurationItemCaptureTime, (err, apiConfigurationItem) => {
if (err) {
callback(err);
}
const configurationItem = convertApiConfiguration(apiConfigurationItem);
callback(null, configurationItem);
});
} else {
checkDefined(invokingEvent.configurationItem, 'configurationItem');
callback(null, invokingEvent.configurationItem);
}
}
// Check whether the resource has been deleted. If the resource was deleted, then the evaluation returns not applicable.
function isApplicable(configurationItem, event) {
checkDefined(configurationItem, 'configurationItem');
checkDefined(event, 'event');
const status = configurationItem.configurationItemStatus;
const eventLeftScope = event.eventLeftScope;
return (status === 'OK' || status === 'ResourceDiscovered') && eventLeftScope === false;
}
// In this example, the resource is compliant if it is an instance and its type matches the type specified as the desired type.
// If the resource is not an instance, then this resource is not applicable.
function evaluateChangeNotificationCompliance(configurationItem, ruleParameters) {
checkDefined(configurationItem, 'configurationItem');
checkDefined(configurationItem.configuration, 'configurationItem.configuration');
checkDefined(ruleParameters, 'ruleParameters');
if (configurationItem.resourceType !== 'AWS::EC2::Instance') {
return 'NOT_APPLICABLE';
} else if (ruleParameters.desiredInstanceType === configurationItem.configuration.instanceType) {
return 'COMPLIANT';
}
return 'NON_COMPLIANT';
}
// Receives the event and context from AWS Lambda.
export const handler = async (event, context) => {
checkDefined(event, 'event');
const invokingEvent = JSON.parse(event.invokingEvent);
const ruleParameters = JSON.parse(event.ruleParameters);
await getConfigurationItem(invokingEvent, async (err, configurationItem) => {
let compliance = 'NOT_APPLICABLE';
let annotation = '';
const putEvaluationsRequest = {};
if (isApplicable(configurationItem, event)) {
// Invoke the compliance checking function.
compliance = evaluateChangeNotificationCompliance(configurationItem, ruleParameters);
if (compliance === "NON_COMPLIANT") {
annotation = "This is an annotation describing why the resource is not compliant.";
}
}
// Initializes the request that contains the evaluation results.
if (annotation) {
putEvaluationsRequest.Evaluations = [
{
ComplianceResourceType: configurationItem.resourceType,
ComplianceResourceId: configurationItem.resourceId,
ComplianceType: compliance,
OrderingTimestamp: new Date(configurationItem.configurationItemCaptureTime),
Annotation: annotation
},
];
} else {
putEvaluationsRequest.Evaluations = [
{
ComplianceResourceType: configurationItem.resourceType,
ComplianceResourceId: configurationItem.resourceId,
ComplianceType: compliance,
OrderingTimestamp: new Date(configurationItem.configurationItemCaptureTime),
},
];
}
putEvaluationsRequest.ResultToken = event.resultToken;
// Sends the evaluation results to AWS Config.
await configClient.send(new PutEvaluationsCommand(putEvaluationsRequest));
});
};
```
**Opérations de la fonction**
La fonction effectue les opérations suivantes lors de l'exécution :
1. La fonction s'exécute lorsque AWS Lambda l'`event`objet est transmis à la `handler` fonction. Dans cet exemple, la fonction accepte le `callback` paramètre facultatif, qu'elle utilise pour renvoyer des informations à l'appelant. AWS Lambda transmet également un `context` objet contenant des informations et des méthodes que la fonction peut utiliser pendant son exécution. Sachez que le contexte n'est plus utilisé dans les nouvelles versions de Lambda.
1. La fonction vérifie si le `messageType` pour l'événement est un élément de configuration ou un élément de configuration surdimensionné, puis renvoie l'élément de configuration.
1. Le gestionnaire appelle la fonction `isApplicable` afin de déterminer si la ressource a été supprimée.
**Note**
Les règles signalant les ressources supprimées doivent renvoyer le résultat de l'évaluation `NOT_APPLICABLE` afin d'éviter des évaluations de règles inutiles.
1. Le gestionnaire appelle la `evaluateChangeNotificationCompliance` fonction et transmet les `ruleParameters` objets `configurationItem` et AWS Config publiés lors de l'événement.
La fonction commence par évaluer si la ressource est une instance EC2. Si la ressource n'est pas une instance EC2, la fonction renvoie la valeur de conformité `NOT_APPLICABLE`.
La fonction évalue ensuite si l'attribut `instanceType` de l'élément de configuration est égal à la valeur du paramètre `desiredInstanceType`. Si les valeurs sont égales, la fonction renvoie `COMPLIANT`. Si les valeurs ne sont pas égales, la fonction renvoie `NON_COMPLIANT`.
1. Le gestionnaire se prépare à envoyer les résultats de l'évaluation à AWS Config en initialisant l'`putEvaluationsRequest`objet. Cet objet comprend le paramètre `Evaluations` qui identifie le résultat de la conformité, le type et l'ID de la ressource qui a été évaluée. L'`putEvaluationsRequest`objet inclut également le jeton de résultat de l'événement, qui identifie la règle et l'événement pour AWS Config.
1. Le gestionnaire envoie les résultats de l'évaluation à AWS Config en transmettant l'objet à la `putEvaluations` méthode du `config` client.
------
#### [ Example Function for Periodic Evaluations ]
AWS Config invoquera une fonction comme dans l'exemple suivant pour les évaluations périodiques. Des évaluations périodiques se produisent à la fréquence que vous spécifiez lorsque vous définissez la règle dans AWS Config.
Si vous utilisez la AWS Config console pour créer une règle associée à une fonction comme dans cet exemple, choisissez **Périodique** comme type de déclencheur. Si vous utilisez l' AWS Config API ou AWS CLI pour créer la règle, définissez l'`MessageType`attribut sur`ScheduledNotification`.
Cet exemple vérifie si le nombre total d'une ressource donnée dépasse le maximum spécifié.
```
'use strict';
import { ConfigServiceClient, ListDiscoveredResourcesCommand, PutEvaluationsCommand } from "@aws-sdk/client-config-service";
const configClient = new ConfigServiceClient({});
// Receives the event and context from AWS Lambda.
export const handler = async (event, context, callback) => {
// Parses the invokingEvent and ruleParameters values, which contain JSON objects passed as strings.
var invokingEvent = JSON.parse(event.invokingEvent),
ruleParameters = JSON.parse(event.ruleParameters),
numberOfResources = 0;
if (isScheduledNotification(invokingEvent) && hasValidRuleParameters(ruleParameters, callback)) {
await countResourceTypes(ruleParameters.applicableResourceType, "", numberOfResources, async function (err, count) {
if (err === null) {
var putEvaluationsRequest;
const compliance = evaluateCompliance(ruleParameters.maxCount, count);
var annotation = '';
if (compliance === "NON_COMPLIANT") {
annotation = "Description of why the resource is not compliant.";
}
// Initializes the request that contains the evaluation results.
if (annotation) {
putEvaluationsRequest = {
Evaluations: [{
// Applies the evaluation result to the AWS account published in the event.
ComplianceResourceType: 'AWS::::Account',
ComplianceResourceId: event.accountId,
ComplianceType: compliance,
OrderingTimestamp: new Date(),
Annotation: annotation
}],
ResultToken: event.resultToken
};
} else {
putEvaluationsRequest = {
Evaluations: [{
// Applies the evaluation result to the AWS account published in the event.
ComplianceResourceType: 'AWS::::Account',
ComplianceResourceId: event.accountId,
ComplianceType: compliance,
OrderingTimestamp: new Date()
}],
ResultToken: event.resultToken
};
}
// Sends the evaluation results to AWS Config.
try {
await configClient.send(new PutEvaluationsCommand(putEvaluationsRequest));
}
catch (e) {
callback(e, null);
}
} else {
callback(err, null);
}
});
} else {
console.log("Invoked for a notification other than Scheduled Notification... Ignoring.");
}
};
// Checks whether the invoking event is ScheduledNotification.
function isScheduledNotification(invokingEvent) {
return (invokingEvent.messageType === 'ScheduledNotification');
}
// Checks the rule parameters to see if they are valid
function hasValidRuleParameters(ruleParameters, callback) {
// Regular express to verify that applicable resource given is a resource type
const awsResourcePattern = /^AWS::(\w*)::(\w*)$/;
const isApplicableResourceType = awsResourcePattern.test(ruleParameters.applicableResourceType);
// Check to make sure the maxCount in the parameters is an integer
const maxCountIsInt = !isNaN(ruleParameters.maxCount) && parseInt(Number(ruleParameters.maxCount)) == ruleParameters.maxCount && !isNaN(parseInt(ruleParameters.maxCount, 10));
if (!isApplicableResourceType) {
callback("The applicableResourceType parameter is not a valid resource type.", null);
}
if (!maxCountIsInt) {
callback("The maxCount parameter is not a valid integer.", null);
}
return isApplicableResourceType && maxCountIsInt;
}
// Checks whether the compliance conditions for the rule are violated.
function evaluateCompliance(maxCount, actualCount) {
if (actualCount > maxCount) {
return "NON_COMPLIANT";
} else {
return "COMPLIANT";
}
}
// Counts the applicable resources that belong to the AWS account.
async function countResourceTypes(applicableResourceType, nextToken, count, callback) {
const input = { resourceType: applicableResourceType, nextToken: nextToken };
const command = new ListDiscoveredResourcesCommand(input);
try {
const response = await configClient.send(command);
count = count + response.resourceIdentifiers.length;
if (response.nextToken !== undefined && response.nextToken != null) {
countResourceTypes(applicableResourceType, response.nextToken, count, callback);
}
callback(null, count);
} catch (e) {
callback(e, null);
}
return count;
}
```
**Opérations de la fonction**
La fonction effectue les opérations suivantes lors de l'exécution :
1. La fonction s'exécute lorsque AWS Lambda l'`event`objet est transmis à la `handler` fonction. Dans cet exemple, la fonction accepte le `callback` paramètre facultatif, qu'elle utilise pour renvoyer des informations à l'appelant. AWS Lambda transmet également un `context` objet contenant des informations et des méthodes que la fonction peut utiliser pendant son exécution. Sachez que le contexte n'est plus utilisé dans les nouvelles versions de Lambda.
1. Pour compter les ressources du type spécifié, le gestionnaire appelle la fonction `countResourceTypes` et il transmet le paramètre `applicableResourceType` qu'il a reçu de l'événement. La fonction `countResourceTypes` appelle la méthode `listDiscoveredResources` du client `config`, qui retourne une liste d'identificateurs pour les ressources applicables. La fonction utilise la longueur de cette liste pour déterminer le nombre de ressources applicables, et elle retourne ce nombre au gestionnaire.
1. Le gestionnaire se prépare à envoyer les résultats de l'évaluation à AWS Config en initialisant l'`putEvaluationsRequest`objet. Cet objet inclut le `Evaluations` paramètre, qui identifie le résultat de conformité et celui Compte AWS qui a été publié lors de l'événement. Vous pouvez utiliser le paramètre `Evaluations` pour appliquer le résultat à n'importe quel type de ressource pris en charge par AWS Config. L'`putEvaluationsRequest`objet inclut également le jeton de résultat de l'événement, qui identifie la règle et l'événement pour AWS Config.
1. Au sein de l'objet `putEvaluationsRequest`, le gestionnaire appelle la fonction `evaluateCompliance`. Cette fonction teste si le nombre de ressources applicables dépasse le maximum attribué au paramètre `maxCount` fourni par l'événement. Si le nombre maximum de ressources est dépassé, la fonction renvoie `NON_COMPLIANT`. Si le nombre maximum de ressources n'est pas dépassé, la fonction renvoie `COMPLIANT`.
1. Le gestionnaire envoie les résultats de l'évaluation à AWS Config en transmettant l'objet à la `putEvaluations` méthode du `config` client.
------
## Exemples de AWS Lambda fonctions pour AWS Config les règles (Python)
AWS Lambda exécute des fonctions en réponse à des événements publiés par les AWS services. La fonction d'une règle Lambda AWS Config personnalisée reçoit un événement publié par AWS Config, puis utilise les données qu'elle reçoit de l'événement et qu'elle extrait de l' AWS Config API pour évaluer la conformité de la règle. Les opérations dans une fonction pour une règle de configuration varient selon qu'il s'agisse d'une évaluation déclenchée par des changements de configuration ou de façon périodique.
Pour plus d'informations sur les modèles courants au sein des AWS Lambda fonctions, voir [Modèle de programmation](https://docs.aws.amazon.com/lambda/latest/dg/programming-model-v2.html) dans le *Guide du AWS Lambda développeur*.
------
#### [ Example Function for Evaluations Triggered by Configuration Changes ]
AWS Config invoquera une fonction comme dans l'exemple suivant lorsqu'elle détecte un changement de configuration pour une ressource comprise dans le champ d'application d'une règle personnalisée.
Si vous utilisez la AWS Config console pour créer une règle associée à une fonction comme dans cet exemple, choisissez **Configuration changes** comme type de déclencheur. Si vous utilisez l' AWS Config API ou AWS CLI pour créer la règle, définissez l'`MessageType`attribut sur `ConfigurationItemChangeNotification` et`OversizedConfigurationItemChangeNotification`. Ces paramètres permettent à votre règle d'être déclenchée chaque fois qu'un élément de configuration ou un élément de configuration surdimensionné est AWS Config généré à la suite d'un changement de ressource.
```
import botocore
import boto3
import json
import datetime
# Set to True to get the lambda to assume the Role attached on the Config Service (useful for cross-account).
ASSUME_ROLE_MODE = False
# This gets the client after assuming the Config service role
# either in the same AWS account or cross-account.
def get_client(service, event):
"""Return the service boto client. It should be used instead of directly calling the client.
Keyword arguments:
service -- the service name used for calling the boto.client()
event -- the event variable given in the lambda handler
"""
if not ASSUME_ROLE_MODE:
return boto3.client(service)
credentials = get_assume_role_credentials(event["executionRoleArn"])
return boto3.client(service, aws_access_key_id=credentials['AccessKeyId'],
aws_secret_access_key=credentials['SecretAccessKey'],
aws_session_token=credentials['SessionToken']
)
# Helper function used to validate input
def check_defined(reference, reference_name):
if not reference:
raise Exception('Error: ', reference_name, 'is not defined')
return reference
# Check whether the message is OversizedConfigurationItemChangeNotification or not
def is_oversized_changed_notification(message_type):
check_defined(message_type, 'messageType')
return message_type == 'OversizedConfigurationItemChangeNotification'
# Get configurationItem using getResourceConfigHistory API
# in case of OversizedConfigurationItemChangeNotification
def get_configuration(resource_type, resource_id, configuration_capture_time):
result = AWS_CONFIG_CLIENT.get_resource_config_history(
resourceType=resource_type,
resourceId=resource_id,
laterTime=configuration_capture_time,
limit=1)
configurationItem = result['configurationItems'][0]
return convert_api_configuration(configurationItem)
# Convert from the API model to the original invocation model
def convert_api_configuration(configurationItem):
for k, v in configurationItem.items():
if isinstance(v, datetime.datetime):
configurationItem[k] = str(v)
configurationItem['awsAccountId'] = configurationItem['accountId']
configurationItem['ARN'] = configurationItem['arn']
configurationItem['configurationStateMd5Hash'] = configurationItem['configurationItemMD5Hash']
configurationItem['configurationItemVersion'] = configurationItem['version']
configurationItem['configuration'] = json.loads(configurationItem['configuration'])
if 'relationships' in configurationItem:
for i in range(len(configurationItem['relationships'])):
configurationItem['relationships'][i]['name'] = configurationItem['relationships'][i]['relationshipName']
return configurationItem
# Based on the type of message get the configuration item
# either from configurationItem in the invoking event
# or using the getResourceConfigHistory API in getConfiguration function.
def get_configuration_item(invokingEvent):
check_defined(invokingEvent, 'invokingEvent')
if is_oversized_changed_notification(invokingEvent['messageType']):
configurationItemSummary = check_defined(invokingEvent['configurationItemSummary'], 'configurationItemSummary')
return get_configuration(configurationItemSummary['resourceType'], configurationItemSummary['resourceId'], configurationItemSummary['configurationItemCaptureTime'])
return check_defined(invokingEvent['configurationItem'], 'configurationItem')
# Check whether the resource has been deleted. If it has, then the evaluation is unnecessary.
def is_applicable(configurationItem, event):
try:
check_defined(configurationItem, 'configurationItem')
check_defined(event, 'event')
except:
return True
status = configurationItem['configurationItemStatus']
eventLeftScope = event['eventLeftScope']
if status == 'ResourceDeleted':
print("Resource Deleted, setting Compliance Status to NOT_APPLICABLE.")
return (status == 'OK' or status == 'ResourceDiscovered') and not eventLeftScope
def get_assume_role_credentials(role_arn):
sts_client = boto3.client('sts')
try:
assume_role_response = sts_client.assume_role(RoleArn=role_arn, RoleSessionName="configLambdaExecution")
return assume_role_response['Credentials']
except botocore.exceptions.ClientError as ex:
# Scrub error message for any internal account info leaks
if 'AccessDenied' in ex.response['Error']['Code']:
ex.response['Error']['Message'] = "AWS Config does not have permission to assume the IAM role."
else:
ex.response['Error']['Message'] = "InternalError"
ex.response['Error']['Code'] = "InternalError"
raise ex
def evaluate_change_notification_compliance(configuration_item, rule_parameters):
check_defined(configuration_item, 'configuration_item')
check_defined(configuration_item['configuration'], 'configuration_item[\'configuration\']')
if rule_parameters:
check_defined(rule_parameters, 'rule_parameters')
if (configuration_item['resourceType'] != 'AWS::EC2::Instance'):
return 'NOT_APPLICABLE'
elif rule_parameters.get('desiredInstanceType'):
if (configuration_item['configuration']['instanceType'] in rule_parameters['desiredInstanceType']):
return 'COMPLIANT'
return 'NON_COMPLIANT'
def lambda_handler(event, context):
global AWS_CONFIG_CLIENT
check_defined(event, 'event')
invoking_event = json.loads(event['invokingEvent'])
rule_parameters = {}
if 'ruleParameters' in event:
rule_parameters = json.loads(event['ruleParameters'])
compliance_value = 'NOT_APPLICABLE'
AWS_CONFIG_CLIENT = get_client('config', event)
configuration_item = get_configuration_item(invoking_event)
if is_applicable(configuration_item, event):
compliance_value = evaluate_change_notification_compliance(
configuration_item, rule_parameters)
response = AWS_CONFIG_CLIENT.put_evaluations(
Evaluations=[
{
'ComplianceResourceType': invoking_event['configurationItem']['resourceType'],
'ComplianceResourceId': invoking_event['configurationItem']['resourceId'],
'ComplianceType': compliance_value,
'OrderingTimestamp': invoking_event['configurationItem']['configurationItemCaptureTime']
},
],
ResultToken=event['resultToken'])
```
**Opérations de la fonction**
La fonction effectue les opérations suivantes lors de l'exécution :
1. La fonction s'exécute lorsque AWS Lambda l'`event`objet est transmis à la `handler` fonction. Dans cet exemple, la fonction accepte le `callback` paramètre facultatif, qu'elle utilise pour renvoyer des informations à l'appelant. AWS Lambda transmet également un `context` objet contenant des informations et des méthodes que la fonction peut utiliser pendant son exécution. Sachez que le contexte n'est plus utilisé dans les nouvelles versions de Lambda.
1. La fonction vérifie si le `messageType` pour l'événement est un élément de configuration ou un élément de configuration surdimensionné, puis renvoie l'élément de configuration.
1. Le gestionnaire appelle la fonction `isApplicable` afin de déterminer si la ressource a été supprimée.
**Note**
Les règles signalant les ressources supprimées doivent renvoyer le résultat de l'évaluation `NOT_APPLICABLE` afin d'éviter des évaluations de règles inutiles.
1. Le gestionnaire appelle la `evaluateChangeNotificationCompliance` fonction et transmet les `ruleParameters` objets `configurationItem` et AWS Config publiés lors de l'événement.
La fonction commence par évaluer si la ressource est une instance EC2. Si la ressource n'est pas une instance EC2, la fonction renvoie la valeur de conformité `NOT_APPLICABLE`.
La fonction évalue ensuite si l'attribut `instanceType` de l'élément de configuration est égal à la valeur du paramètre `desiredInstanceType`. Si les valeurs sont égales, la fonction renvoie `COMPLIANT`. Si les valeurs ne sont pas égales, la fonction renvoie `NON_COMPLIANT`.
1. Le gestionnaire se prépare à envoyer les résultats de l'évaluation à AWS Config en initialisant l'`putEvaluationsRequest`objet. Cet objet comprend le paramètre `Evaluations` qui identifie le résultat de la conformité, le type et l'ID de la ressource qui a été évaluée. L'`putEvaluationsRequest`objet inclut également le jeton de résultat de l'événement, qui identifie la règle et l'événement pour AWS Config.
1. Le gestionnaire envoie les résultats de l'évaluation à AWS Config en transmettant l'objet à la `putEvaluations` méthode du `config` client.
------
#### [ Example Function for Periodic Evaluations ]
AWS Config invoquera une fonction comme dans l'exemple suivant pour les évaluations périodiques. Des évaluations périodiques se produisent à la fréquence que vous spécifiez lorsque vous définissez la règle dans AWS Config.
Si vous utilisez la AWS Config console pour créer une règle associée à une fonction comme dans cet exemple, choisissez **Périodique** comme type de déclencheur. Si vous utilisez l' AWS Config API ou AWS CLI pour créer la règle, définissez l'`MessageType`attribut sur`ScheduledNotification`.
```
import botocore
import boto3
import json
import datetime
# Set to True to get the lambda to assume the Role attached on the Config Service (useful for cross-account).
ASSUME_ROLE_MODE = False
DEFAULT_RESOURCE_TYPE = 'AWS::::Account'
# This gets the client after assuming the Config service role
# either in the same AWS account or cross-account.
def get_client(service, event):
"""Return the service boto client. It should be used instead of directly calling the client.
Keyword arguments:
service -- the service name used for calling the boto.client()
event -- the event variable given in the lambda handler
"""
if not ASSUME_ROLE_MODE:
return boto3.client(service)
credentials = get_assume_role_credentials(event["executionRoleArn"])
return boto3.client(service, aws_access_key_id=credentials['AccessKeyId'],
aws_secret_access_key=credentials['SecretAccessKey'],
aws_session_token=credentials['SessionToken']
)
def get_assume_role_credentials(role_arn):
sts_client = boto3.client('sts')
try:
assume_role_response = sts_client.assume_role(RoleArn=role_arn, RoleSessionName="configLambdaExecution")
return assume_role_response['Credentials']
except botocore.exceptions.ClientError as ex:
# Scrub error message for any internal account info leaks
if 'AccessDenied' in ex.response['Error']['Code']:
ex.response['Error']['Message'] = "AWS Config does not have permission to assume the IAM role."
else:
ex.response['Error']['Message'] = "InternalError"
ex.response['Error']['Code'] = "InternalError"
raise ex
# Check whether the message is a ScheduledNotification or not.
def is_scheduled_notification(message_type):
return message_type == 'ScheduledNotification'
def count_resource_types(applicable_resource_type, next_token, count):
resource_identifier = AWS_CONFIG_CLIENT.list_discovered_resources(resourceType=applicable_resource_type, nextToken=next_token)
updated = count + len(resource_identifier['resourceIdentifiers']);
return updated
# Evaluates the configuration items in the snapshot and returns the compliance value to the handler.
def evaluate_compliance(max_count, actual_count):
return 'NON_COMPLIANT' if int(actual_count) > int(max_count) else 'COMPLIANT'
def evaluate_parameters(rule_parameters):
if 'applicableResourceType' not in rule_parameters:
raise ValueError('The parameter with "applicableResourceType" as key must be defined.')
if not rule_parameters['applicableResourceType']:
raise ValueError('The parameter "applicableResourceType" must have a defined value.')
return rule_parameters
# This generate an evaluation for config
def build_evaluation(resource_id, compliance_type, event, resource_type=DEFAULT_RESOURCE_TYPE, annotation=None):
"""Form an evaluation as a dictionary. Usually suited to report on scheduled rules.
Keyword arguments:
resource_id -- the unique id of the resource to report
compliance_type -- either COMPLIANT, NON_COMPLIANT or NOT_APPLICABLE
event -- the event variable given in the lambda handler
resource_type -- the CloudFormation resource type (or AWS::::Account) to report on the rule (default DEFAULT_RESOURCE_TYPE)
annotation -- an annotation to be added to the evaluation (default None)
"""
eval_cc = {}
if annotation:
eval_cc['Annotation'] = annotation
eval_cc['ComplianceResourceType'] = resource_type
eval_cc['ComplianceResourceId'] = resource_id
eval_cc['ComplianceType'] = compliance_type
eval_cc['OrderingTimestamp'] = str(json.loads(event['invokingEvent'])['notificationCreationTime'])
return eval_cc
def lambda_handler(event, context):
global AWS_CONFIG_CLIENT
evaluations = []
rule_parameters = {}
resource_count = 0
max_count = 0
invoking_event = json.loads(event['invokingEvent'])
if 'ruleParameters' in event:
rule_parameters = json.loads(event['ruleParameters'])
valid_rule_parameters = evaluate_parameters(rule_parameters)
compliance_value = 'NOT_APPLICABLE'
AWS_CONFIG_CLIENT = get_client('config', event)
if is_scheduled_notification(invoking_event['messageType']):
result_resource_count = count_resource_types(valid_rule_parameters['applicableResourceType'], '', resource_count)
if valid_rule_parameters.get('maxCount'):
max_count = valid_rule_parameters['maxCount']
compliance_value = evaluate_compliance(max_count, result_resource_count)
evaluations.append(build_evaluation(event['accountId'], compliance_value, event, resource_type=DEFAULT_RESOURCE_TYPE))
response = AWS_CONFIG_CLIENT.put_evaluations(Evaluations=evaluations, ResultToken=event['resultToken'])
```
**Opérations de la fonction**
La fonction effectue les opérations suivantes lors de l'exécution :
1. La fonction s'exécute lorsque AWS Lambda l'`event`objet est transmis à la `handler` fonction. Dans cet exemple, la fonction accepte le `callback` paramètre facultatif, qu'elle utilise pour renvoyer des informations à l'appelant. AWS Lambda transmet également un `context` objet contenant des informations et des méthodes que la fonction peut utiliser pendant son exécution. Sachez que le contexte n'est plus utilisé dans les nouvelles versions de Lambda.
1. Pour compter les ressources du type spécifié, le gestionnaire appelle la fonction `countResourceTypes` et il transmet le paramètre `applicableResourceType` qu'il a reçu de l'événement. La fonction `countResourceTypes` appelle la méthode `listDiscoveredResources` du client `config`, qui retourne une liste d'identificateurs pour les ressources applicables. La fonction utilise la longueur de cette liste pour déterminer le nombre de ressources applicables, et elle retourne ce nombre au gestionnaire.
1. Le gestionnaire se prépare à envoyer les résultats de l'évaluation à AWS Config en initialisant l'`putEvaluationsRequest`objet. Cet objet inclut le `Evaluations` paramètre, qui identifie le résultat de conformité et celui Compte AWS qui a été publié lors de l'événement. Vous pouvez utiliser le paramètre `Evaluations` pour appliquer le résultat à n'importe quel type de ressource pris en charge par AWS Config. L'`putEvaluationsRequest`objet inclut également le jeton de résultat de l'événement, qui identifie la règle et l'événement pour AWS Config.
1. Au sein de l'objet `putEvaluationsRequest`, le gestionnaire appelle la fonction `evaluateCompliance`. Cette fonction teste si le nombre de ressources applicables dépasse le maximum attribué au paramètre `maxCount` fourni par l'événement. Si le nombre maximum de ressources est dépassé, la fonction renvoie `NON_COMPLIANT`. Si le nombre maximum de ressources n'est pas dépassé, la fonction renvoie `COMPLIANT`.
1. Le gestionnaire envoie les résultats de l'évaluation à AWS Config en transmettant l'objet à la `putEvaluations` méthode du `config` client.
------
## Exemples d'événements pour les AWS Config règles
Lorsque le déclencheur d'une règle se produit, AWS Config invoque la AWS Lambda fonction de la règle en publiant un événement. AWS Lambda Exécute ensuite la fonction en transmettant l'événement au gestionnaire de la fonction.
------
#### [ Example Event for Evaluations Triggered by Configuration Changes ]
AWS Config publie un événement lorsqu'il détecte un changement de configuration pour une ressource comprise dans le champ d'application d'une règle. L'exemple d'événement suivant montre que la règle a été déclenchée par une modification de la configuration d'une instance EC2.
```
{
"invokingEvent": "{\"configurationItem\":{\"configurationItemCaptureTime\":\"2016-02-17T01:36:34.043Z\",\"awsAccountId\":\"123456789012\",\"configurationItemStatus\":\"OK\",\"resourceId\":\"i-00000000\",\"ARN\":\"arn:aws:ec2:us-east-2:123456789012:instance/i-00000000\",\"awsRegion\":\"us-east-2\",\"availabilityZone\":\"us-east-2a\",\"resourceType\":\"AWS::EC2::Instance\",\"tags\":{\"Foo\":\"Bar\"},\"relationships\":[{\"resourceId\":\"eipalloc-00000000\",\"resourceType\":\"AWS::EC2::EIP\",\"name\":\"Is attached to ElasticIp\"}],\"configuration\":{\"foo\":\"bar\"}},\"messageType\":\"ConfigurationItemChangeNotification\"}",
"ruleParameters": "{\"myParameterKey\":\"myParameterValue\"}",
"resultToken": "myResultToken",
"eventLeftScope": false,
"executionRoleArn": "arn:aws:iam::123456789012:role/config-role",
"configRuleArn": "arn:aws:config:us-east-2:123456789012:config-rule/config-rule-0123456",
"configRuleName": "change-triggered-config-rule",
"configRuleId": "config-rule-0123456",
"accountId": "123456789012",
"version": "1.0"
}
```
------
#### [ Example Event for Evaluations Triggered by Oversized Configuration Changes ]
Certaines modifications de ressources génèrent des éléments de configuration surdimensionnés. L'exemple d'événement suivant montre que la règle a été déclenchée par une modification de la configuration surdimensionnée d'une instance EC2.
```
{
"invokingEvent": "{\"configurationItemSummary\": {\"changeType\": \"UPDATE\",\"configurationItemVersion\": \"1.2\",\"configurationItemCaptureTime\":\"2016-10-06T16:46:16.261Z\",\"configurationStateId\": 0,\"awsAccountId\":\"123456789012\",\"configurationItemStatus\": \"OK\",\"resourceType\": \"AWS::EC2::Instance\",\"resourceId\":\"i-00000000\",\"resourceName\":null,\"ARN\":\"arn:aws:ec2:us-west-2:123456789012:instance/i-00000000\",\"awsRegion\": \"us-west-2\",\"availabilityZone\":\"us-west-2a\",\"configurationStateMd5Hash\":\"8f1ee69b287895a0f8bc5753eca68e96\",\"resourceCreationTime\":\"2016-10-06T16:46:10.489Z\"},\"messageType\":\"OversizedConfigurationItemChangeNotification\"}",
"ruleParameters": "{\"myParameterKey\":\"myParameterValue\"}",
"resultToken": "myResultToken",
"eventLeftScope": false,
"executionRoleArn": "arn:aws:iam::123456789012:role/config-role",
"configRuleArn": "arn:aws:config:us-east-2:123456789012:config-rule/config-rule-ec2-managed-instance-inventory",
"configRuleName": "change-triggered-config-rule",
"configRuleId": "config-rule-0123456",
"accountId": "123456789012",
"version": "1.0"
}
```
------
#### [ Example Event for Evaluations Triggered by Periodic Frequency ]
AWS Config publie un événement lorsqu'il évalue vos ressources à une fréquence que vous spécifiez (par exemple toutes les 24 heures). L'exemple d'événement suivant montre que la règle a été déclenchée par une fréquence périodique.
```
{
"invokingEvent": "{\"awsAccountId\":\"123456789012\",\"notificationCreationTime\":\"2016-07-13T21:50:00.373Z\",\"messageType\":\"ScheduledNotification\",\"recordVersion\":\"1.0\"}",
"ruleParameters": "{\"myParameterKey\":\"myParameterValue\"}",
"resultToken": "myResultToken",
"eventLeftScope": false,
"executionRoleArn": "arn:aws:iam::123456789012:role/config-role",
"configRuleArn": "arn:aws:config:us-east-2:123456789012:config-rule/config-rule-0123456",
"configRuleName": "periodic-config-rule",
"configRuleId": "config-rule-6543210",
"accountId": "123456789012",
"version": "1.0"
}
```
------
### Attributs d'événement
L'objet JSON d'un AWS Config événement contient les attributs suivants :
`invokingEvent`
L'événement qui déclenche l'évaluation d'une règle. Si l'événement est publié en réponse à un changement de configuration de ressource, la valeur de cet attribut est une chaîne qui contient un élément de configuration JSON `configurationItem` ou un `configurationItemSummary` (pour les éléments de configuration surdimensionnés). L'élément de configuration représente l'état de la ressource au moment où le changement a AWS Config été détecté. Pour un exemple d'élément de configuration, consultez le résultat produit par la `get-resource-config-history` AWS CLI commande dans[Affichage de l'historique de configuration](view-manage-resource-console.md#get-config-history-cli).
Si l'événement est publié pour une évaluation périodique, la valeur est une chaîne qui contient un objet JSON. L'objet comporte des informations sur l'évaluation qui a été déclenchée.
Pour chaque type d'événement, une fonction doit analyser la chaîne avec un analyseur JSON afin d'être en mesure d'évaluer son contenu, comme illustré dans l'exemple suivant de Node.js :
```
var invokingEvent = JSON.parse(event.invokingEvent);
```
`ruleParameters`
Paires clé/valeur que la fonction traite dans le cadre de sa logique d'évaluation. Vous définissez des paramètres lorsque vous utilisez la AWS Config console pour créer une règle Lambda personnalisée. Vous pouvez également définir des paramètres avec l'`InputParameters`attribut dans la demande `PutConfigRule` AWS Config d'API ou dans la `put-config-rule` AWS CLI commande.
Le code JSON pour les paramètres est contenu dans une chaîne, donc une fonction doit analyser la chaîne avec un analyseur JSON afin d'être en mesure d'évaluer son contenu, comme illustré dans l'exemple suivant de Node.js :
```
var ruleParameters = JSON.parse(event.ruleParameters);
```
`resultToken`
Un jeton auquel la fonction doit être transmise AWS Config lors de l'`PutEvaluations`appel.
`eventLeftScope`
Valeur booléenne qui indique si la AWS ressource à évaluer a été supprimée du champ d'application de la règle. Si la valeur est `true`, la fonction indique que l'évaluation peut être ignorée en transmettant `NOT_APPLICABLE` en tant que valeur pour l'attribut `ComplianceType` dans l'appel de `PutEvaluations`.
`executionRoleArn`
L'ARN du rôle IAM attribué à AWS Config.
`configRuleArn`
L'ARN AWS Config attribué à la règle.
`configRuleName`
Le nom que vous avez attribué à la règle qui a entraîné la publication AWS Config de l'événement et l'appel de la fonction.
`configRuleId`
L'ID AWS Config attribué à la règle.
`accountId`
L'ID du propriétaire Compte AWS de la règle.
`version`
Numéro de version attribué par AWS. La version augmentera si des attributs sont AWS ajoutés aux AWS Config événements. Si une fonction requiert un attribut qui figure uniquement dans des événements qui correspondent à ou dépassent une version spécifique, cette fonction peut vérifier la valeur de cet attribut.
La version actuelle pour les AWS Config événements est 1.0.
# Gestion des ressources supprimées pour les règles Lambda AWS Config personnalisées
Les règles signalant les ressources supprimées doivent renvoyer le résultat de l'évaluation `NOT_APPLICABLE` afin d'éviter des évaluations de règles inutiles.
Lorsque vous supprimez une ressource, AWS Config crée un `configurationItem` avec `ResourceDeleted` pour`configurationItemStatus`. Vous pouvez utiliser ces métadonnées pour vérifier si une règle signale une ressource supprimée. Pour plus d'informations sur les éléments de configuration, consultez [Concepts \$1 Éléments de configuration](https://docs.aws.amazon.com/config/latest/developerguide/config-concepts.html#config-items.html).
Incluez les extraits de code suivants pour vérifier les ressources supprimées et définissez le résultat de l'évaluation d'une règle Lambda AWS Config personnalisée sur le fait qu'elle indique une ressource supprimée : `NOT_APPLICABLE`
------
#### [ Custom Lambda Rules (Node.js) ]
```
// Check whether the resource has been deleted. If the resource was deleted, then the evaluation returns not applicable.
function isApplicable(configurationItem, event) {
checkDefined(configurationItem, 'configurationItem');
checkDefined(event, 'event');
const status = configurationItem.configurationItemStatus;
const eventLeftScope = event.eventLeftScope;
return (status === 'OK' || status === 'ResourceDiscovered') && eventLeftScope === false;
}
```
------
#### [ Custom Lambda Rules (Python) ]
```
# Check whether the resource has been deleted. If the resource was deleted, then the evaluation returns not applicable.
def is_applicable(configurationItem, event):
try:
check_defined(configurationItem, 'configurationItem')
check_defined(event, 'event')
except:
return True
status = configurationItem['configurationItemStatus']
eventLeftScope = event['eventLeftScope']
if status == 'ResourceDeleted':
print("Resource Deleted, setting Compliance Status to NOT_APPLICABLE.")
return (status == 'OK' or status == 'ResourceDiscovered') and not eventLeftScope
```
------
**Note**
AWS Config les règles gérées et les règles de politique AWS Config personnalisées gèrent ce comportement par défaut.
Si vous créez une règle Lambd AWS Config personnalisée avec Python à l'aide du kit de AWS Config développement (RDK) et de la bibliothèque AWS Config du kit de développement (RDKlib), la classe [Evaluator](https://github.com/awslabs/aws-config-rdklib/blob/master/rdklib/evaluator.py#L56) importée vérifiera ce comportement. Pour plus d'informations sur la façon d'écrire des règles avec le RDK et RDKlib, voir [Écrire des règles avec le RDK](https://docs.aws.amazon.com/config/latest/developerguide/evaluate-config_components.html#evaluate-config_components_logic) et. RDKlib