Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# AWS Config Reglas personalizadas
AWS Config Las reglas personalizadas son reglas que se crean desde cero. Hay dos formas de crear reglas AWS Config personalizadas: con funciones de Lambda ([Guía para AWS Lambda desarrolladores](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html#gettingstarted-concepts-function)) y con Guard ([Guard GitHub Repository](https://github.com/aws-cloudformation/cloudformation-guard)), un policy-as-code lenguaje.
AWS Config *las reglas personalizadas creadas con Lambda se denominan reglas *AWS Config Lambda AWS Config personalizadas y las reglas* personalizadas creadas con Guard se denominan AWS Config reglas de políticas personalizadas.*
Antes de utilizar reglas personalizadas, consulte [Consideraciones](evaluate-config.md#evaluate-config-considerations).
## AWS Config Reglas de políticas personalizadas
Las reglas escritas con Guard se pueden crear desde la AWS Config consola o mediante la AWS Config regla APIs. AWS Config Las reglas de políticas personalizadas le permiten crear reglas AWS Config personalizadas sin necesidad de usar Java o Python para desarrollar funciones Lambda para administrar sus reglas personalizadas. AWS Config Las reglas de políticas personalizadas se inician mediante cambios en la configuración. Para obtener más información sobre Guard, consulte el [ GitHubrepositorio de Guard](https://github.com/aws-cloudformation/cloudformation-guard).
## AWS Config Reglas Lambda personalizadas
Las reglas Lambda personalizadas ofrecen la opción de usar Java o Python para crear una función Lambda para una regla personalizada. AWS Config Una *función Lambda* es un código personalizado en el que se carga y se invoca mediante eventos publicados en ella por una fuente de eventos. AWS Lambda Si la función Lambda está asociada a una AWS Config regla, la AWS Config invoca cuando se inicia la regla. A continuación, la función Lambda evalúa la información de configuración que envía y devuelve los AWS Config resultados de la evaluación. Para obtener más información sobre las funciones de Lambda, consulte [Function and Event Sources](https://docs.aws.amazon.com/lambda/latest/dg/intro-core-components.html) en la *Guía para desarrolladores de AWS Lambda *.
## Diferencias de formato para las reglas personalizadas AWS Config
En la siguiente tabla se muestran las diferencias de formato en los campos del tipo de [ConfigurationItem](https://docs.aws.amazon.com/config/latest/APIReference/API_ConfigurationItem.html)datos y de las reglas AWS Config personalizadas.
| ConfigurationItem | AWS Config Regla personalizada |
| --- | --- |
| version | configurationItemVersion |
| accountId | awsAccountId |
| arn | ARN |
| configurationItemMD5Hash | configurationStateMd5Hash |
**Topics**
+ [Reglas de políticas personalizadas](#evaluate-config_develop-rules-policy)
+ [Reglas de Lambda personalizadas](#evaluate-config_develop-rules-lambda)
+ [Diferencias de formato para las reglas personalizadas AWS Config](#evaluate-config_develop-schema)
+ [Creación de reglas de políticas personalizadas](evaluate-config_develop-rules_cfn-guard.md)
+ [Creación de reglas de Lambda personalizadas](evaluate-config_develop-rules_lambda-functions.md)
+ [Administración de los recursos eliminados para reglas de Lambda personalizadas de](evaluate-config_develop-rules-delete.md)
# Creación de reglas de políticas AWS Config personalizadas
Puede crear reglas de política AWS Config personalizadas desde la Consola de administración de AWS AWS CLI, o la AWS Config API.
## Añadir reglas de política AWS Config personalizadas
------
#### [ Using the console ]
1. Inicia sesión en la AWS Config consola de [https://console.aws.amazon.com/config/tu casa Consola de administración de AWS](https://console.aws.amazon.com/config/home) y ábrela.
1. En el Consola de administración de AWS menú, compruebe que el selector de regiones esté configurado en una AWS región que admita AWS Config reglas. Para ver una lista de las regiones admitidas, consulte [AWS Config Regions and Endpoints](https://docs.aws.amazon.com/general/latest/gr/awsconfig.html) en la *Referencia general de Amazon Web Services*.
1. En el panel de navegación izquierdo, seleccione **Rules (Reglas)**.
1. En la página **Rules (Reglas)**, seleccione **Add rule (Añadir regla)**.
1. En la página **Especificar tipo de regla**, elija **Crear una regla personalizada con Guard**.
1. En la página **Configurar regla**, cree la regla siguiendo estos pasos:
1. En **Nombre**, escriba un nombre único para la regla.
1. En **Descripción**, escriba una descripción para la regla.
1. Para la **versión de tiempo de ejecución de Guard**, elija el sistema de tiempo de ejecución para su regla de política AWS Config personalizada.
1. Para **Contenido de la regla**, puede indicar la política personalizada de Guard correspondiente a su regla.
1. Para **el modo de evaluación**, elija en qué momento del proceso de creación y administración de recursos AWS Config desea evaluar sus recursos. Según la regla, AWS Config puede evaluar las configuraciones de sus recursos antes de aprovisionar un recurso, después de aprovisionar un recurso o ambas cosas.
1. Elija **Active la evaluación proactiva** para ejecutar evaluaciones de los valores de configuración de sus recursos antes de que se implementen.
Una vez que hayas activado la evaluación proactiva, puedes usar la [StartResourceEvaluation](https://docs.aws.amazon.com/config/latest/APIReference/API_StartResourceEvaluation.html)API y la [GetResourceEvaluationSummary](https://docs.aws.amazon.com/config/latest/APIReference/API_GetResourceEvaluationSummary.html)API para comprobar si los recursos que especificas en estos comandos se marcarán como NO CONFORMES según las reglas proactivas de tu cuenta en tu región.
Para obtener más información sobre el uso de estos comandos, consulta Cómo [evaluar tus recursos con reglas](https://docs.aws.amazon.com/config/latest/developerguide/evaluating-your-resources.html#evaluating-your-resources-proactive). AWS Config Para obtener una lista de reglas administradas que admiten una evaluación proactiva, consulte [la Lista de reglas AWS Config administradas por modo de evaluación](https://docs.aws.amazon.com/config/latest/developerguide/managed-rules-by-evaluation-mode.html).
1. Seleccione **Active la evaluación de detectives** para evaluar los ajustes de la configuración de los recursos existentes.
Para una evaluación detectivesca, las reglas de política AWS Config personalizadas se inician mediante **cambios en la configuración**. Esta opción estará preseleccionada.
+ **Recursos**: cuando se crea, cambia o elimina un recurso específico que coincide con un tipo de recurso específico o con un tipo más el identificador.
+ **Etiquetas**: cuando se crea, cambia o elimina un recurso con la etiqueta especificada.
+ **Todos los cambios**: cuando AWS Config se crea, modifica o elimina un recurso registrado por.
AWS Config ejecuta la evaluación cuando detecta un cambio en un recurso que coincide con el alcance de la regla. Puede utilizar el ámbito para restringir qué recursos inician evaluaciones. De lo contrario, las evaluaciones se inician cuando se produce un cambio en un recurso aprovisionado posteriormente.
1. Si su regla incluye **Parámetros**, puede personalizar los valores de las claves proporcionadas. Un parámetro es un atributo que deben cumplir los recursos para que se considere que cumplen la regla.
1. En la página **Revisar y crear**, revise todas las selecciones antes de añadir la regla a la Cuenta de AWS.
1. Cuando termine de revisar las reglas, seleccione **Agregar regla**.
------
#### [ Using the AWS CLI ]
Utilice el comando [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).
El campo `Owner` debe ser `CUSTOM_POLICY`. Los siguientes campos adicionales son obligatorios para las reglas de política AWS Config personalizada:
+ `Runtime`: El sistema de ejecución de sus reglas de política AWS Config personalizada.
+ `PolicyText`: definición de la política que contiene la lógica de las reglas de políticas personalizadas de AWS Config .
+ `EnableDebugLogDelivery`: La expresión booleana para habilitar el registro de depuración para la regla de política AWS Config personalizada. El valor predeterminado es `false`.
------
#### [ Using the API Reference ]
Utilice la acción [PutConfigRule](https://docs.aws.amazon.com/config/latest/APIReference/API_PutConfigRule.html).
El campo `Owner` debe ser `CUSTOM_POLICY`. Los siguientes campos adicionales son obligatorios para las reglas de política AWS Config personalizada:
+ `Runtime`: El sistema de ejecución de sus reglas de política AWS Config personalizada.
+ `PolicyText`: definición de la política que contiene la lógica de las reglas de políticas personalizadas de AWS Config .
+ `EnableDebugLogDelivery`: La expresión booleana para habilitar el registro de depuración para la regla de política AWS Config personalizada. El valor predeterminado es `false`.
------
## Escribir el contenido de las reglas de las políticas personalizadas AWS Config
Con las reglas de políticas AWS Config personalizadas, puede usar el lenguaje específico de dominio (DSL) de AWS CloudFormation Guard para evaluar las configuraciones de los recursos. En este tema se proporcionan patrones y prácticas recomendadas para escribir reglas de políticas personalizadas.
Para obtener más información sobre cómo escribir reglas con Guard, consulte Cómo [escribir reglas de Guard](https://docs.aws.amazon.com/cfn-guard/latest/ug/writing-rules.html) en la Guía del usuario de AWS CloudFormation Guard y los [modos de funcionamiento de AWS CloudFormation Guard 2.0 en el repositorio de](https://github.com/aws-cloudformation/cloudformation-guard/tree/main/guard) Guard. GitHub
### Estructura básica de reglas
Utilice el siguiente formato básico para crear reglas:
```
# 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
}
```
### Componentes principales
configuración
Incluye el contenido de la configuración de recursos.
supplementaryConfiguration
Contiene contenido adicional para la configuración de recursos. AWS Config devuelve este campo para determinados tipos de recursos a fin de complementar la información devuelta para el campo de configuración.
resourceType
AWS tipo de recurso que se está evaluando.
resourceId
ID del recurso (por ejemplo, `sg-xxxxxx`).
accountId
El Cuenta de AWS identificador de 12 dígitos asociado al recurso.
### Patrones comunes
------
#### [ 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 <>
}}
```
------
### Características avanzadas
------
#### [ 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
}
```
------
### Prácticas recomendadas
+ Utilice variables con instrucciones `let` para mejorar la legibilidad.
+ Agrupe comprobaciones relacionadas mediante bloques de reglas con nombre.
+ Incluya comentarios descriptivos.
+ Utilice operadores adecuados (`exists`, `is_string`, `is_list`).
+ Utilice patrones de expresiones regulares sin distinción entre mayúsculas y minúsculas.
### Ejemplo: dynamodb-pitr-enabled
El siguiente ejemplo muestra la definición de política para una versión de regla de política AWS Config personalizada de la regla AWS Config [dynamodb-pitr-enabled](dynamodb-pitr-enabled.md) administrada. Esta regla comprueba si las tablas Point-in-Time de DynamoDB tienen habilitada la recuperación.
```
# 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" <>
}
```
# Creación de AWS Config reglas Lambda personalizadas
Puede desarrollar reglas personalizadas y añadirlas AWS Config con AWS Lambda funciones.
Cada regla personalizada se asocia a una función Lambda, que contiene la lógica que evalúa si los AWS recursos cumplen con la regla. Se asocia esta función a la regla y la regla invoca la función en respuesta a los cambios de configuración, o bien de forma periódica. A continuación, la función evalúa si los recursos cumplen con la regla y envía los resultados de la evaluación a. AWS Config
## AWS Kit de desarrollo de reglas (RDK)
El kit de desarrollo de AWS reglas (RDK) está diseñado para respaldar un flujo de trabajo basado en el «cumplimiento según el código», que es intuitivo y productivo. Elimina gran parte del trabajo pesado e indiferenciado asociado a la implementación de AWS Config reglas respaldadas por funciones Lambda personalizadas y proporciona un proceso iterativo simplificado. develop-deploy-monitor
Para obtener step-by-step instrucciones, consulte la documentación del [kit de desarrollo de AWS reglas](https://aws-config-rdk.readthedocs.io/en/master) (RDK).
## Ejemplos de AWS Lambda funciones para AWS Config reglas (Node.js)
AWS Lambda ejecuta funciones en respuesta a eventos publicados por los AWS servicios. La función de una regla Lambda AWS Config personalizada recibe un evento publicado por y AWS Config, a continuación, utiliza los datos que recibe del evento y que recupera de la AWS Config API para evaluar el cumplimiento de la regla. Las operaciones que hay en una función de una regla de configuración son diferentes en función de si realiza una evaluación que se activa por los cambios en la configuración o se activa de forma periódica.
Para obtener información sobre los patrones comunes dentro de AWS Lambda las funciones, consulte el [Modelo de programación](https://docs.aws.amazon.com/lambda/latest/dg/programming-model-v2.html) en la Guía *AWS Lambda para desarrolladores*.
------
#### [ Example Function for Evaluations Triggered by Configuration Changes ]
AWS Config invocará una función como la del ejemplo siguiente cuando detecte un cambio en la configuración de un recurso que esté dentro del ámbito de una regla personalizada.
Si usa la AWS Config consola para crear una regla asociada a una función como en este ejemplo, elija **Cambios de configuración** como tipo de activación. Si usa la AWS Config API o AWS CLI para crear la regla, defina el `MessageType` atributo en `ConfigurationItemChangeNotification` y`OversizedConfigurationItemChangeNotification`. Estos ajustes permiten que la regla se active cada vez que se AWS Config genere un elemento de configuración o un elemento de configuración sobredimensionado como resultado de un cambio de recurso.
En este ejemplo, se evalúan los recursos y se comprueba si las instancias coinciden con el tipo de recurso: `AWS::EC2::Instance`. La regla se activa cuando AWS Config genera un elemento de configuración o una notificación de un elemento de configuración sobredimensionado.
```
'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));
});
};
```
**Operaciones de funciones**
La función realiza las siguientes operaciones en tiempo de ejecución:
1. La función se ejecuta cuando AWS Lambda pasa el `event` objeto a la `handler` función. En este ejemplo, la función acepta el `callback` parámetro opcional, que utiliza para devolver información a la persona que llama. AWS Lambda también pasa un `context` objeto, que contiene información y métodos que la función puede utilizar mientras se ejecuta. Tenga en cuenta que en las versiones más recientes de Lambda, el contexto ya no se usa.
1. La función comprueba si el `messageType` del evento es un elemento de configuración o un elemento de configuración sobredimensionado y, a continuación, devuelve el elemento de configuración.
1. El controlador llama a la función `isApplicable` para determinar si el recurso se ha eliminado.
**nota**
Las reglas que informen sobre los recursos eliminados deben devolver el resultado de la evaluación de `NOT_APPLICABLE` para evitar evaluaciones innecesarias de las reglas.
1. El controlador llama a la `evaluateChangeNotificationCompliance` función y pasa los `ruleParameters` objetos `configurationItem` y AWS Config publicados en el evento.
La función evalúa primero si el recurso es una instancia EC2. Si el recurso no es una instancia EC2, la función devuelve un valor de conformidad de `NOT_APPLICABLE`.
Luego, la función evalúa si el atributo `instanceType` del elemento de configuración es igual al valor del parámetro `desiredInstanceType`. Si los valores son iguales, la función devuelve `COMPLIANT`. Si los valores no son iguales, la función devuelve `NON_COMPLIANT`.
1. El controlador se prepara para enviar los resultados de la evaluación AWS Config inicializando el objeto. `putEvaluationsRequest` Este objeto incluye el parámetro `Evaluations`, que identifica el resultado de conformidad, el tipo de recurso y el ID del recurso que se ha evaluado. El `putEvaluationsRequest` objeto también incluye el token de resultados del evento, que identifica la regla y el evento. AWS Config
1. El controlador envía los resultados de la evaluación pasando el objeto al `putEvaluations` método del `config` cliente. AWS Config
------
#### [ Example Function for Periodic Evaluations ]
AWS Config invocará una función como la del siguiente ejemplo para las evaluaciones periódicas. Las evaluaciones periódicas se producen con la frecuencia que especifique al definir la regla en AWS Config.
Si usa la AWS Config consola para crear una regla asociada a una función como en este ejemplo, elija **Periódico** como tipo de activación. Si usa la AWS Config API o AWS CLI para crear la regla, defina el `MessageType` atributo en`ScheduledNotification`.
En este ejemplo, se comprueba si el número total de un recurso especificado supera un máximo especificado.
```
'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;
}
```
**Operaciones de funciones**
La función realiza las siguientes operaciones en tiempo de ejecución:
1. La función se ejecuta cuando AWS Lambda pasa el `event` objeto a la `handler` función. En este ejemplo, la función acepta el `callback` parámetro opcional, que utiliza para devolver información a la persona que llama. AWS Lambda también pasa un `context` objeto, que contiene información y métodos que la función puede utilizar mientras se ejecuta. Tenga en cuenta que en las versiones más recientes de Lambda, el contexto ya no se usa.
1. Para contar los recursos del tipo especificado, el controlador llama a la función `countResourceTypes` y pasa el parámetro `applicableResourceType` que ha recibido del evento. La función `countResourceTypes` llama al método `listDiscoveredResources` del cliente `config`, que devuelve una lista de identificadores para los recursos aplicables. La función utiliza la longitud de esta lista para determinar el número de recursos aplicables y devuelve este número al controlador.
1. El controlador se prepara para enviar los resultados de la evaluación AWS Config inicializando el `putEvaluationsRequest` objeto. Este objeto incluye el `Evaluations` parámetro, que identifica el resultado de conformidad y el Cuenta de AWS que se publicó en el evento. Puede utilizar el parámetro `Evaluations` para aplicar el resultado a cualquier tipo de recurso admitido por AWS Config. El `putEvaluationsRequest` objeto también incluye el token de resultado del evento, que identifica la regla y el evento AWS Config.
1. En el objeto `putEvaluationsRequest`, el controlador llama a la función `evaluateCompliance`. Esta función comprueba si el número de recursos aplicables supera el máximo asignado al parámetro `maxCount`, proporcionado anteriormente por el evento. Si el número de recursos supera el máximo, la función devuelve `NON_COMPLIANT`. Si el número de recursos no supera el máximo, la función devuelve `COMPLIANT`.
1. El controlador envía los resultados de la evaluación pasando el objeto al `putEvaluations` método del `config` cliente. AWS Config
------
## Ejemplos de AWS Lambda funciones para AWS Config reglas (Python)
AWS Lambda ejecuta funciones en respuesta a eventos publicados por los AWS servicios. La función de una regla Lambda AWS Config personalizada recibe un evento publicado por y AWS Config, a continuación, utiliza los datos que recibe del evento y que recupera de la AWS Config API para evaluar el cumplimiento de la regla. Las operaciones que hay en una función de una regla de configuración son diferentes en función de si realiza una evaluación que se activa por los cambios en la configuración o se activa de forma periódica.
Para obtener información sobre los patrones comunes dentro de AWS Lambda las funciones, consulte el [Modelo de programación](https://docs.aws.amazon.com/lambda/latest/dg/programming-model-v2.html) en la Guía *AWS Lambda para desarrolladores*.
------
#### [ Example Function for Evaluations Triggered by Configuration Changes ]
AWS Config invocará una función como la del ejemplo siguiente cuando detecte un cambio en la configuración de un recurso que esté dentro del ámbito de una regla personalizada.
Si usa la AWS Config consola para crear una regla asociada a una función como en este ejemplo, elija **Cambios de configuración** como tipo de activación. Si usa la AWS Config API o AWS CLI para crear la regla, defina el `MessageType` atributo en `ConfigurationItemChangeNotification` y`OversizedConfigurationItemChangeNotification`. Estos ajustes permiten que la regla se active cada vez que se AWS Config genere un elemento de configuración o un elemento de configuración sobredimensionado como resultado de un cambio de recurso.
```
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'])
```
**Operaciones de funciones**
La función realiza las siguientes operaciones en tiempo de ejecución:
1. La función se ejecuta cuando AWS Lambda pasa el `event` objeto a la `handler` función. En este ejemplo, la función acepta el `callback` parámetro opcional, que utiliza para devolver información a la persona que llama. AWS Lambda también pasa un `context` objeto, que contiene información y métodos que la función puede utilizar mientras se ejecuta. Tenga en cuenta que en las versiones más recientes de Lambda, el contexto ya no se usa.
1. La función comprueba si el `messageType` del evento es un elemento de configuración o un elemento de configuración sobredimensionado y, a continuación, devuelve el elemento de configuración.
1. El controlador llama a la función `isApplicable` para determinar si el recurso se ha eliminado.
**nota**
Las reglas que informen sobre los recursos eliminados deben devolver el resultado de la evaluación de `NOT_APPLICABLE` para evitar evaluaciones innecesarias de las reglas.
1. El controlador llama a la `evaluateChangeNotificationCompliance` función y pasa los `ruleParameters` objetos `configurationItem` y AWS Config publicados en el evento.
La función evalúa primero si el recurso es una instancia EC2. Si el recurso no es una instancia EC2, la función devuelve un valor de conformidad de `NOT_APPLICABLE`.
Luego, la función evalúa si el atributo `instanceType` del elemento de configuración es igual al valor del parámetro `desiredInstanceType`. Si los valores son iguales, la función devuelve `COMPLIANT`. Si los valores no son iguales, la función devuelve `NON_COMPLIANT`.
1. El controlador se prepara para enviar los resultados de la evaluación AWS Config inicializando el objeto. `putEvaluationsRequest` Este objeto incluye el parámetro `Evaluations`, que identifica el resultado de conformidad, el tipo de recurso y el ID del recurso que se ha evaluado. El `putEvaluationsRequest` objeto también incluye el token de resultados del evento, que identifica la regla y el evento. AWS Config
1. El controlador envía los resultados de la evaluación pasando el objeto al `putEvaluations` método del `config` cliente. AWS Config
------
#### [ Example Function for Periodic Evaluations ]
AWS Config invocará una función como la del siguiente ejemplo para las evaluaciones periódicas. Las evaluaciones periódicas se producen con la frecuencia que especifique al definir la regla en AWS Config.
Si usa la AWS Config consola para crear una regla asociada a una función como en este ejemplo, elija **Periódico** como tipo de activación. Si usa la AWS Config API o AWS CLI para crear la regla, defina el `MessageType` atributo en`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'])
```
**Operaciones de funciones**
La función realiza las siguientes operaciones en tiempo de ejecución:
1. La función se ejecuta cuando AWS Lambda pasa el `event` objeto a la `handler` función. En este ejemplo, la función acepta el `callback` parámetro opcional, que utiliza para devolver información a la persona que llama. AWS Lambda también pasa un `context` objeto, que contiene información y métodos que la función puede utilizar mientras se ejecuta. Tenga en cuenta que en las versiones más recientes de Lambda, el contexto ya no se usa.
1. Para contar los recursos del tipo especificado, el controlador llama a la función `countResourceTypes` y pasa el parámetro `applicableResourceType` que ha recibido del evento. La función `countResourceTypes` llama al método `listDiscoveredResources` del cliente `config`, que devuelve una lista de identificadores para los recursos aplicables. La función utiliza la longitud de esta lista para determinar el número de recursos aplicables y devuelve este número al controlador.
1. El controlador se prepara para enviar los resultados de la evaluación AWS Config inicializando el `putEvaluationsRequest` objeto. Este objeto incluye el `Evaluations` parámetro, que identifica el resultado de conformidad y el Cuenta de AWS que se publicó en el evento. Puede utilizar el parámetro `Evaluations` para aplicar el resultado a cualquier tipo de recurso admitido por AWS Config. El `putEvaluationsRequest` objeto también incluye el token de resultado del evento, que identifica la regla y el evento AWS Config.
1. En el objeto `putEvaluationsRequest`, el controlador llama a la función `evaluateCompliance`. Esta función comprueba si el número de recursos aplicables supera el máximo asignado al parámetro `maxCount`, proporcionado anteriormente por el evento. Si el número de recursos supera el máximo, la función devuelve `NON_COMPLIANT`. Si el número de recursos no supera el máximo, la función devuelve `COMPLIANT`.
1. El controlador envía los resultados de la evaluación pasando el objeto al `putEvaluations` método del `config` cliente. AWS Config
------
## Ejemplos de eventos para reglas AWS Config
Cuando se produce el desencadenador de una regla, AWS Config invoca la AWS Lambda función de la regla publicando un evento. A continuación, AWS Lambda ejecuta la función pasando el evento al controlador de la función.
------
#### [ Example Event for Evaluations Triggered by Configuration Changes ]
AWS Config publica un evento cuando detecta un cambio en la configuración de un recurso que está dentro del ámbito de una regla. El siguiente ejemplo de evento muestra que la regla se ha activado por un cambio de configuración en una instancia 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 ]
Algunos cambios de recursos generan elementos de configuración sobredimensionados. El siguiente ejemplo de evento muestra que la regla se ha activado por un cambio de configuración sobredimensionado en una instancia 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 publica un evento cuando evalúa sus recursos con la frecuencia que especifique (por ejemplo, cada 24 horas). El siguiente evento de ejemplo muestra que la regla se ha activado por una frecuencia periódica.
```
{
"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"
}
```
------
### Atributos del evento
El objeto JSON de un AWS Config evento contiene los siguientes atributos:
`invokingEvent`
El evento que dispara la evaluación de una regla. Si el evento se publica en respuesta a un cambio de configuración de recurso, el valor de este atributo es una cadena que contiene un `configurationItem` JSON o un `configurationItemSummary` (para elementos de configuración sobredimensionados). El elemento de configuración representa el estado del recurso en el momento en que AWS Config se detectó el cambio. Para ver un ejemplo de un elemento de configuración, consulte el resultado generado por el `get-resource-config-history` AWS CLI comando en[Visualización del historial de configuración](view-manage-resource-console.md#get-config-history-cli).
Si el evento se publica para una evaluación periódica, el valor es una cadena que contiene un objeto JSON. El objeto incluye información sobre la evaluación que se ha activado.
Para cada tipo de evento, una función debe analizar la cadena con un analizador JSON para poder evaluar su contenido, tal y como se muestra en el siguiente ejemplo Node.js:
```
var invokingEvent = JSON.parse(event.invokingEvent);
```
`ruleParameters`
Pares clave/valor que la función procesa como parte de su lógica de evaluación. Los parámetros se definen cuando se utiliza la AWS Config consola para crear una regla Lambda personalizada. También puede definir los parámetros con el `InputParameters` atributo de la solicitud de `PutConfigRule` AWS Config API o el `put-config-rule` AWS CLI comando.
El código JSON de los parámetros está almacenado dentro de una cadena, por lo que una función debe analizar la cadena con un analizador JSON para poder evaluar su contenido, tal y como se muestra en el siguiente ejemplo Node.js:
```
var ruleParameters = JSON.parse(event.ruleParameters);
```
`resultToken`
Un token al que la función debe pasar AWS Config con la `PutEvaluations` llamada.
`eventLeftScope`
Un valor booleano que indica si el AWS recurso que se va a evaluar se ha eliminado del ámbito de la regla. Si el valor es `true`, la función indica que la evaluación se puede pasar por alto aprobando `NOT_APPLICABLE` como el valor para el atributo `ComplianceType` en la llamada `PutEvaluations`.
`executionRoleArn`
El ARN de la función de IAM a la que está asignada. AWS Config
`configRuleArn`
El ARN que se AWS Config asignó a la regla.
`configRuleName`
El nombre que asignó a la regla que provocó AWS Config la publicación del evento y la invocación de la función.
`configRuleId`
El ID que se AWS Config asignó a la regla.
`accountId`
El ID del propietario Cuenta de AWS de la regla.
`version`
Un número de versión asignado por AWS. La versión aumentará si AWS agrega atributos a los AWS Config eventos. Si una función requiere un atributo que solo está en eventos que cumplan o superen una versión específica, entonces esa función puede comprobar el valor de este atributo.
La versión actual para los AWS Config eventos es la 1.0.
# Administración de recursos eliminados para AWS Config reglas Lambda personalizadas
Las reglas que informen sobre los recursos eliminados deben devolver el resultado de la evaluación de `NOT_APPLICABLE` para evitar evaluaciones innecesarias de las reglas.
Al eliminar un recurso, AWS Config crea un `configurationItem` ancho `ResourceDeleted` para el`configurationItemStatus`. Puede utilizar estos metadatos para comprobar si una regla informa sobre un recurso eliminado. Para obtener más información sobre los elementos de configuración, consulte [Conceptos \$1 Elementos de configuración](https://docs.aws.amazon.com/config/latest/developerguide/config-concepts.html#config-items.html).
Incluye los siguientes fragmentos de código para comprobar si hay recursos eliminados y establecer el resultado de la evaluación de una regla lambda AWS Config personalizada en `NOT_APPLICABLE` caso de que informe sobre un recurso eliminado:
------
#### [ 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
```
------
**nota**
AWS Config Las reglas administradas y las reglas de política AWS Config personalizadas controlan este comportamiento de forma predeterminada.
Si crea una regla lambd AWS Config personalizada con Python mediante el kit de AWS Config desarrollo (RDK) y la biblioteca del kit de AWS Config desarrollo (RDKlib), la clase [Evaluator](https://github.com/awslabs/aws-config-rdklib/blob/master/rdklib/evaluator.py#L56) importada comprobará este comportamiento. Para obtener información sobre cómo escribir reglas con el RDK RDKlib, consulte [Escribir reglas con](https://docs.aws.amazon.com/config/latest/developerguide/evaluate-config_components.html#evaluate-config_components_logic) el RDK y. RDKlib