Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # AWS Config Regole personalizzate AWS Config Le regole personalizzate sono regole create da zero. Esistono due modi per creare regole AWS Config personalizzate: con le funzioni Lambda ([AWS Lambda Developer Guide](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html#gettingstarted-concepts-function)) e con Guard ([Guard GitHub Repository](https://github.com/aws-cloudformation/cloudformation-guard)), un linguaggio. policy-as-code AWS Config *le regole personalizzate create con Lambda sono chiamate Regole *AWS Config Lambda AWS Config personalizzate e le regole* personalizzate create con Guard sono chiamate AWS Config Regole di policy personalizzate.* Prima di utilizzare regole personalizzate, consulta. [Considerazioni](evaluate-config.md#evaluate-config-considerations) ## AWS Config Regole di policy personalizzate Le regole scritte utilizzando Guard possono essere create dalla AWS Config console o utilizzando la AWS Config regola APIs. AWS Config Le regole Custom Policy consentono di creare regole AWS Config personalizzate senza dover utilizzare Java o Python per sviluppare funzioni Lambda per gestire le regole personalizzate. AWS Config Le regole Custom Policy vengono avviate mediante modifiche alla configurazione. Per ulteriori informazioni su Guard, consulta il [Guard GitHub Repository](https://github.com/aws-cloudformation/cloudformation-guard). ## AWS Config Regole Lambda personalizzate Le regole Lambda personalizzate offrono la possibilità di utilizzare Java o Python per creare una funzione Lambda per una regola personalizzata. AWS Config Una *funzione Lambda* è codice personalizzato su cui si carica e viene richiamata da eventi pubblicati su di essa da un'origine di eventi. AWS Lambda Se la funzione Lambda è associata a una AWS Config regola, la AWS Config richiama all'avvio della regola. La funzione Lambda valuta quindi le informazioni di configurazione inviate da e restituisce AWS Config i risultati della valutazione. Per ulteriori informazioni sulle funzioni Lambda, consulta [Origini di eventi e funzioni](https://docs.aws.amazon.com/lambda/latest/dg/intro-core-components.html) nella *Guida per gli sviluppatori di AWS Lambda *. ## Differenze di formato per le regole personalizzate AWS Config La tabella seguente mostra le differenze di formato nei campi per il tipo di [ConfigurationItem](https://docs.aws.amazon.com/config/latest/APIReference/API_ConfigurationItem.html)dati e per le regole AWS Config personalizzate. | ConfigurationItem | AWS Config Regola personalizzata | | --- | --- | | version | configurationItemVersion | | accountId | awsAccountId | | arn | ARN | | configurationItemMD5Hash | configurationStateMd5Hash | **Topics** + [Regole di policy personalizzate](#evaluate-config_develop-rules-policy) + [Regole Lambda personalizzate](#evaluate-config_develop-rules-lambda) + [ ## Differenze di formato per le regole personalizzate AWS Config ](#evaluate-config_develop-schema) + [Creazione di regole di policy personalizzate](evaluate-config_develop-rules_cfn-guard.md) + [Creazione di regole Lambda personalizzate](evaluate-config_develop-rules_lambda-functions.md) + [Gestione delle risorse eliminate per le regole Lambda personalizzate](evaluate-config_develop-rules-delete.md) # Creazione di regole di policy AWS Config personalizzate Puoi creare regole di policy AWS Config personalizzate da Console di gestione AWS AWS CLI, o AWS Config API. ## Aggiungere regole di policy AWS Config personalizzate ------ #### [ Using the console ] 1. Accedi a Console di gestione AWS e apri la AWS Config console a [https://console.aws.amazon.com/config/casa](https://console.aws.amazon.com/config/home). 1. Nel Console di gestione AWS menu, verifica che il selettore della regione sia impostato su una AWS regione che supporta AWS Config le regole. Per un elenco delle regioni supportate, consulta [Regioni ed endpoint AWS Config](https://docs.aws.amazon.com/general/latest/gr/awsconfig.html) in *Riferimenti generali di Amazon Web Services*. 1. Nel riquadro di navigazione di sinistra seleziona **Rules (Regole)**. 1. Nella pagina **Rules (Regole)** scegli **Add rule (Aggiungi regola)**. 1. Nella pagina **Specifica il tipo di regola**, scegli **Crea una regola personalizzata utilizzando Guard**. 1. Nella pagina **Configura regola**, crea la regola con la seguente procedura: 1. In **Nome regola**, digita un nome univoco per la regola. 1. In **Descrizione**, digita una descrizione per la regola. 1. Per la **versione runtime di Guard**, scegli il sistema di runtime per la tua regola AWS Config Custom Policy. 1. In **Contenuti delle regole**, puoi inserire la policy Guard personalizzata per la regola. 1. Per la **modalità Valutazione**, scegli in che momento del processo di creazione e gestione delle risorse desideri AWS Config valutare le tue risorse. A seconda della regola, è AWS Config possibile valutare le configurazioni delle risorse prima che venga assegnato il provisioning di una risorsa, dopo l'assegnazione di una risorsa o entrambe le cose. 1. Scegli **Attivazione della valutazione proattiva** per eseguire valutazioni sulle impostazioni di configurazione delle risorse prima che vengano implementate. Dopo aver attivato la valutazione proattiva, puoi utilizzare l'[StartResourceEvaluation](https://docs.aws.amazon.com/config/latest/APIReference/API_StartResourceEvaluation.html)API e l'[GetResourceEvaluationSummary](https://docs.aws.amazon.com/config/latest/APIReference/API_GetResourceEvaluationSummary.html)API per verificare se le risorse specificate in questi comandi verranno contrassegnate come NON CONFORMI dalle regole proattive del tuo account nella tua regione. [Per ulteriori informazioni sull'utilizzo di questi comandi, consulta Evaluating Your Resources with Rules. AWS Config](https://docs.aws.amazon.com/config/latest/developerguide/evaluating-your-resources.html#evaluating-your-resources-proactive) Per un elenco delle regole gestite che supportano la valutazione proattiva, vedere [Elenco delle regole AWS Config gestite per modalità di valutazione](https://docs.aws.amazon.com/config/latest/developerguide/managed-rules-by-evaluation-mode.html). 1. Seleziona **Attivazione della valutazione dei test** per valutare le impostazioni di configurazione delle risorse esistenti. Per una valutazione approfondita, le regole AWS Config Custom Policy vengono avviate mediante modifiche alla **configurazione**. Questa opzione sarà preselezionata. + **Risorse**: quando viene creata, modificata o eliminata una risorsa che corrisponde al tipo o al tipo più identificatore specificato. + **Tag**: quando viene creata, modificata o eliminata una risorsa con il tag specificato. + **Tutte le modifiche**: quando una risorsa registrata da AWS Config viene creata, modificata o eliminata. AWS Config esegue la valutazione quando rileva una modifica a una risorsa che corrisponde all'ambito della regola. Puoi utilizzare l'ambito per vincolare quali risorse avviano le valutazioni. Altrimenti, le valutazioni vengono avviate quando viene apportata una modifica a una risorsa dopo il suo provisioning. 1. Se la regola include parametri, puoi personalizzare i valori delle chiavi fornite in **Parametri**. Un parametro è un attributo a cui le risorse devono aderire per essere considerate conformi alla regola. 1. Nella pagina **Rivedi e crea**, esamina tutte le tue selezioni prima di aggiungere la regola alla tua. Account AWS 1. Al termine della revisione delle regole, scegli **Aggiungi regola**. ------ #### [ Using the AWS CLI ] Utilizza il 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). Il campo `Owner` deve essere `CUSTOM_POLICY`. I seguenti campi aggiuntivi sono obbligatori per le regole delle politiche AWS Config personalizzate: + `Runtime`: Il sistema di runtime per le regole AWS Config Custom Policy. + `PolicyText`: la definizione della policy contenente la logica per le regole di policy AWS Config personalizzate. + `EnableDebugLogDelivery`: L'espressione booleana per abilitare la registrazione di debug per la regola Custom Policy. AWS Config Il valore predefinito è `false`. ------ #### [ Using the API Reference ] Usa l'azione [PutConfigRule](https://docs.aws.amazon.com/config/latest/APIReference/API_PutConfigRule.html). Il campo `Owner` deve essere `CUSTOM_POLICY`. I seguenti campi aggiuntivi sono obbligatori per AWS Config le regole Custom Policy: + `Runtime`: Il sistema di runtime per le regole AWS Config Custom Policy. + `PolicyText`: la definizione della policy contenente la logica per le regole di policy AWS Config personalizzate. + `EnableDebugLogDelivery`: L'espressione booleana per abilitare la registrazione di debug per la regola Custom Policy. AWS Config Il valore predefinito è `false`. ------ ## Scrittura del contenuto delle regole per le regole Custom Policy AWS Config Con le regole AWS Config Custom Policy, puoi utilizzare il linguaggio DSL (Domain-Specific Language) di AWS CloudFormation Guard per valutare le configurazioni delle risorse. Questo argomento fornisce modelli e best practice per scrivere regole di policy personalizzate. Per ulteriori informazioni su come scrivere regole con Guard, consulta [Writing Guard rules](https://docs.aws.amazon.com/cfn-guard/latest/ug/writing-rules.html) nella AWS CloudFormation Guard User Guide e [Modes of Operation di AWS CloudFormation Guard 2.0](https://github.com/aws-cloudformation/cloudformation-guard/tree/main/guard) nel Guard GitHub Repository. ### Struttura delle regole di base Utilizza il seguente formato di base per creare regole: ``` # 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 } ``` ### Componenti chiave configurazione Contiene i contenuti per la configurazione delle risorse. supplementaryConfiguration Contiene contenuti aggiuntivi per la configurazione delle risorse. AWS Config restituisce questo campo per determinati tipi di risorse per integrare le informazioni restituite per il campo di configurazione. resourceType AWS tipo di risorsa in fase di valutazione. resourceId L'ID della risorsa (ad esempio,`sg-xxxxxx`). accountId L' Account AWS ID a 12 cifre associato alla risorsa. ### Schemi comuni ------ #### [ 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 <> }} ``` ------ ### Funzionalità avanzate ------ #### [ 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 } ``` ------ ### Best practice + Usa variabili con `let` istruzioni per una migliore leggibilità. + Raggruppa i controlli correlati utilizzando blocchi di regole denominati. + Includi commenti descrittivi. + Usa gli operatori appropriati (`exists`,`is_string`,`is_list`). + Usa modelli regex con corrispondenza senza distinzione tra maiuscole e minuscole. ### Esempio: dynamodb-pitr-enabled L'esempio seguente mostra la definizione della politica per una versione della regola AWS Config Custom Policy della Managed rule. AWS Config [dynamodb-pitr-enabled](dynamodb-pitr-enabled.md) Questa regola verifica se nelle tabelle Point-in-Time DynamoDB è abilitato il ripristino. ``` # 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" <> } ``` # Creazione di AWS Config regole Lambda personalizzate È possibile sviluppare regole personalizzate e aggiungerle AWS Config con AWS Lambda funzioni. Associate ogni regola personalizzata a una funzione Lambda, che contiene la logica che valuta se le AWS risorse sono conformi alla regola. Puoi associare questa funzione alla tua regola e la regola richiama la funzione in risposta a modifiche di configurazione oppure periodicamente. La funzione valuta quindi se le risorse sono conformi alla regola e invia i risultati della valutazione a. AWS Config ## AWS Kit di sviluppo delle regole (RDK) Il AWS Rule Development Kit (RDK) è progettato per supportare un flusso di lavoro «Compliance-as-Code» intuitivo e produttivo. Elimina gran parte del lavoro indifferenziato associato all'implementazione di AWS Config regole supportate da funzioni Lambda personalizzate e fornisce un processo iterativo semplificato. develop-deploy-monitor Per step-by-step istruzioni, consulta la documentazione del [AWS Rule](https://aws-config-rdk.readthedocs.io/en/master) Development Kit (RDK). ## AWS Lambda Funzioni di esempio per AWS Config le regole (Node.js) AWS Lambda esegue funzioni in risposta a eventi pubblicati dai AWS servizi. La funzione per una regola Lambda AWS Config personalizzata riceve un evento pubblicato da AWS Config e utilizza quindi i dati che riceve dall'evento e recupera dall' AWS Config API per valutare la conformità della regola. Le operazioni in una funzione per una regola di configurazione variano a seconda che si esegua una valutazione attivata da modifiche di configurazione o attivata periodicamente. Per informazioni sui modelli comuni all'interno AWS Lambda delle funzioni, consulta [Programming Model](https://docs.aws.amazon.com/lambda/latest/dg/programming-model-v2.html) nella *AWS Lambda Developer* Guide. ------ #### [ Example Function for Evaluations Triggered by Configuration Changes ] AWS Config invocherà una funzione come nell'esempio seguente quando rileva una modifica alla configurazione per una risorsa che rientra nell'ambito di una regola personalizzata. Se utilizzi la AWS Config console per creare una regola associata a una funzione come questo esempio, scegli **Modifiche alla configurazione** come tipo di trigger. Se utilizzi l' AWS Config API o AWS CLI per creare la regola, imposta l'`MessageType`attributo su `ConfigurationItemChangeNotification` and`OversizedConfigurationItemChangeNotification`. Queste impostazioni consentono di attivare la regola ogni volta che viene AWS Config generato un elemento di configurazione o un elemento di configurazione sovradimensionato a seguito di una modifica delle risorse. Questo esempio valuta le risorse e verifica che le istanze corrispondano al tipo di risorsa, `AWS::EC2::Instance`. La regola viene attivata quando AWS Config genera un elemento di configurazione o un notifica di un elemento di configurazione di dimensioni eccessive. ``` '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)); }); }; ``` **Operazioni della funzione** La funzione esegue le operazioni seguenti in fase di runtime: 1. La funzione viene eseguita quando AWS Lambda passa l'`event`oggetto alla `handler` funzione. In questo esempio, la funzione accetta il `callback` parametro opzionale, che utilizza per restituire informazioni al chiamante. AWS Lambda passa anche un `context` oggetto, che contiene informazioni e metodi che la funzione può utilizzare durante l'esecuzione. Tieni presente che nelle versioni più recenti di Lambda il contesto non è più utilizzato. 1. La funzione verifica che il `messageType` per l'evento sia un elemento di configurazione o un elemento di configurazione di dimensioni eccessive e quindi restituisce l'elemento di configurazione. 1. Il gestore chiama la funzione `isApplicable` per determinare se la risorsa sia stato eliminata. **Nota** Le regole che segnalano le risorse eliminate devono restituire il risultato della valutazione di `NOT_APPLICABLE` per evitare valutazioni non necessarie delle regole. 1. Il gestore chiama la `evaluateChangeNotificationCompliance` funzione e passa gli `ruleParameters` oggetti `configurationItem` and AWS Config pubblicati nell'evento. La funzione prima valuta se la risorsa è un'istanza EC2. Se la risorsa non è un'istanza EC2, la funzione restituisce un valore di conformità di `NOT_APPLICABLE`. La funzione valuta quindi se l'attributo `instanceType` nell'elemento di configurazione sia pari al valore del parametro `desiredInstanceType`. Se i valori sono uguali, la funzione restituisce `COMPLIANT`. Se i valori non sono uguali, la funzione restituisce `NON_COMPLIANT`. 1. Il gestore si prepara a inviare i risultati della valutazione AWS Config inizializzando l'oggetto. `putEvaluationsRequest` Questo oggetto include il parametro `Evaluations`, che identifica il risultato di conformità, il tipo di risorsa e l'ID della risorsa che è stata valutata. L'`putEvaluationsRequest`oggetto include anche il token dei risultati dell'evento, che identifica la regola e l'evento per. AWS Config 1. Il gestore invia i risultati della valutazione AWS Config passando l'oggetto al `putEvaluations` metodo del `config` client. ------ #### [ Example Function for Periodic Evaluations ] AWS Config invocherà una funzione come nell'esempio seguente per le valutazioni periodiche. Le valutazioni periodiche si verificano con la frequenza che specifichi quando definisci la regola in AWS Config. Se usi la AWS Config console per creare una regola associata a una funzione come questo esempio, scegli **Periodic** come tipo di trigger. Se utilizzi l' AWS Config API o AWS CLI per creare la regola, imposta l'`MessageType`attributo `ScheduledNotification` su. Questo esempio verifica se il numero totale di una risorsa specificata supera il limite massimo impostato. ``` '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; } ``` **Operazioni della funzione** La funzione esegue le operazioni seguenti in fase di runtime: 1. La funzione viene eseguita quando AWS Lambda passa l'`event`oggetto alla `handler` funzione. In questo esempio, la funzione accetta il `callback` parametro opzionale, che utilizza per restituire informazioni al chiamante. AWS Lambda passa anche un `context` oggetto, che contiene informazioni e metodi che la funzione può utilizzare durante l'esecuzione. Tieni presente che nelle versioni più recenti di Lambda il contesto non è più utilizzato. 1. Per contare le risorse del tipo specificato, il gestore chiama la funzione `countResourceTypes` e trasferisce il parametro `applicableResourceType` che ha ricevuto dall'evento. La funzione `countResourceTypes` chiama il metodo `listDiscoveredResources` del client `config`, che restituisce un elenco di identificatori per le risorse applicabili. La funzione utilizza la lunghezza di questo elenco per determinare il numero di risorse applicabili e restituisce questo conteggio al gestore. 1. Il gestore si prepara a inviare i risultati della valutazione AWS Config inizializzando l'oggetto. `putEvaluationsRequest` Questo oggetto include il `Evaluations` parametro, che identifica il risultato di conformità e Account AWS quello che è stato pubblicato nell'evento. Puoi utilizzare il parametro `Evaluations` per applicare il risultato a qualsiasi tipo di risorsa supportata da AWS Config. L'`putEvaluationsRequest`oggetto include anche il token dei risultati dell'evento, che identifica la regola e l'evento per. AWS Config 1. All'interno dell'oggetto `putEvaluationsRequest`, il gestore chiama la funzione `evaluateCompliance`, Questa funzione verifica se il numero di risorse applicabili supera il massimo assegnato al parametro `maxCount`, che è stato fornito dall'evento. Se il numero di risorse supera il limite massimo, la funzione restituisce `NON_COMPLIANT`. Se il numero di risorse non supera il limite massimo, la funzione restituisce `COMPLIANT`. 1. Il gestore invia i risultati della valutazione AWS Config passando l'oggetto al `putEvaluations` metodo del `config` client. ------ ## AWS Lambda Funzioni di esempio per AWS Config le regole (Python) AWS Lambda esegue funzioni in risposta a eventi pubblicati dai AWS servizi. La funzione per una regola Lambda AWS Config personalizzata riceve un evento pubblicato da AWS Config e utilizza quindi i dati che riceve dall'evento e recupera dall' AWS Config API per valutare la conformità della regola. Le operazioni in una funzione per una regola di configurazione variano a seconda che si esegua una valutazione attivata da modifiche di configurazione o attivata periodicamente. Per informazioni sui modelli comuni all'interno AWS Lambda delle funzioni, consulta [Programming Model](https://docs.aws.amazon.com/lambda/latest/dg/programming-model-v2.html) nella *AWS Lambda Developer* Guide. ------ #### [ Example Function for Evaluations Triggered by Configuration Changes ] AWS Config invocherà una funzione come nell'esempio seguente quando rileva una modifica alla configurazione per una risorsa che rientra nell'ambito di una regola personalizzata. Se utilizzi la AWS Config console per creare una regola associata a una funzione come questo esempio, scegli **Modifiche alla configurazione** come tipo di trigger. Se utilizzi l' AWS Config API o AWS CLI per creare la regola, imposta l'`MessageType`attributo su `ConfigurationItemChangeNotification` and`OversizedConfigurationItemChangeNotification`. Queste impostazioni consentono di attivare la regola ogni volta che viene AWS Config generato un elemento di configurazione o un elemento di configurazione sovradimensionato a seguito di una modifica delle risorse. ``` 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']) ``` **Operazioni della funzione** La funzione esegue le operazioni seguenti in fase di runtime: 1. La funzione viene eseguita quando AWS Lambda passa l'`event`oggetto alla `handler` funzione. In questo esempio, la funzione accetta il `callback` parametro opzionale, che utilizza per restituire informazioni al chiamante. AWS Lambda passa anche un `context` oggetto, che contiene informazioni e metodi che la funzione può utilizzare durante l'esecuzione. Tieni presente che nelle versioni più recenti di Lambda il contesto non è più utilizzato. 1. La funzione verifica che il `messageType` per l'evento sia un elemento di configurazione o un elemento di configurazione di dimensioni eccessive e quindi restituisce l'elemento di configurazione. 1. Il gestore chiama la funzione `isApplicable` per determinare se la risorsa sia stato eliminata. **Nota** Le regole che segnalano le risorse eliminate devono restituire il risultato della valutazione di `NOT_APPLICABLE` per evitare valutazioni non necessarie delle regole. 1. Il gestore chiama la `evaluateChangeNotificationCompliance` funzione e passa gli `ruleParameters` oggetti `configurationItem` and AWS Config pubblicati nell'evento. La funzione prima valuta se la risorsa è un'istanza EC2. Se la risorsa non è un'istanza EC2, la funzione restituisce un valore di conformità di `NOT_APPLICABLE`. La funzione valuta quindi se l'attributo `instanceType` nell'elemento di configurazione sia pari al valore del parametro `desiredInstanceType`. Se i valori sono uguali, la funzione restituisce `COMPLIANT`. Se i valori non sono uguali, la funzione restituisce `NON_COMPLIANT`. 1. Il gestore si prepara a inviare i risultati della valutazione AWS Config inizializzando l'oggetto. `putEvaluationsRequest` Questo oggetto include il parametro `Evaluations`, che identifica il risultato di conformità, il tipo di risorsa e l'ID della risorsa che è stata valutata. L'`putEvaluationsRequest`oggetto include anche il token dei risultati dell'evento, che identifica la regola e l'evento per. AWS Config 1. Il gestore invia i risultati della valutazione AWS Config passando l'oggetto al `putEvaluations` metodo del `config` client. ------ #### [ Example Function for Periodic Evaluations ] AWS Config invocherà una funzione come nell'esempio seguente per le valutazioni periodiche. Le valutazioni periodiche si verificano con la frequenza che specifichi quando definisci la regola in AWS Config. Se usi la AWS Config console per creare una regola associata a una funzione come questo esempio, scegli **Periodic** come tipo di trigger. Se utilizzi l' AWS Config API o AWS CLI per creare la regola, imposta l'`MessageType`attributo `ScheduledNotification` su. ``` 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']) ``` **Operazioni della funzione** La funzione esegue le operazioni seguenti in fase di runtime: 1. La funzione viene eseguita quando AWS Lambda passa l'`event`oggetto alla `handler` funzione. In questo esempio, la funzione accetta il `callback` parametro opzionale, che utilizza per restituire informazioni al chiamante. AWS Lambda passa anche un `context` oggetto, che contiene informazioni e metodi che la funzione può utilizzare durante l'esecuzione. Tieni presente che nelle versioni più recenti di Lambda il contesto non è più utilizzato. 1. Per contare le risorse del tipo specificato, il gestore chiama la funzione `countResourceTypes` e trasferisce il parametro `applicableResourceType` che ha ricevuto dall'evento. La funzione `countResourceTypes` chiama il metodo `listDiscoveredResources` del client `config`, che restituisce un elenco di identificatori per le risorse applicabili. La funzione utilizza la lunghezza di questo elenco per determinare il numero di risorse applicabili e restituisce questo conteggio al gestore. 1. Il gestore si prepara a inviare i risultati della valutazione AWS Config inizializzando l'oggetto. `putEvaluationsRequest` Questo oggetto include il `Evaluations` parametro, che identifica il risultato di conformità e Account AWS quello che è stato pubblicato nell'evento. Puoi utilizzare il parametro `Evaluations` per applicare il risultato a qualsiasi tipo di risorsa supportata da AWS Config. L'`putEvaluationsRequest`oggetto include anche il token dei risultati dell'evento, che identifica la regola e l'evento per. AWS Config 1. All'interno dell'oggetto `putEvaluationsRequest`, il gestore chiama la funzione `evaluateCompliance`, Questa funzione verifica se il numero di risorse applicabili supera il massimo assegnato al parametro `maxCount`, che è stato fornito dall'evento. Se il numero di risorse supera il limite massimo, la funzione restituisce `NON_COMPLIANT`. Se il numero di risorse non supera il limite massimo, la funzione restituisce `COMPLIANT`. 1. Il gestore invia i risultati della valutazione AWS Config passando l'oggetto al `putEvaluations` metodo del `config` client. ------ ## Eventi di esempio per le regole AWS Config Quando si verifica l'attivazione di una regola, AWS Config richiama la AWS Lambda funzione della regola pubblicando un evento. Quindi AWS Lambda esegue la funzione passando l'evento al gestore della funzione. ------ #### [ Example Event for Evaluations Triggered by Configuration Changes ] AWS Config pubblica un evento quando rileva una modifica alla configurazione per una risorsa che rientra nell'ambito di una regola. L'esempio seguente mostra che la regola è stata attivata da una modifica di configurazione per un'istanza 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 ] Alcune modifiche delle risorse generano elementi di configurazione di dimensioni eccessive. L'esempio seguente mostra che la regola è stata attivata da una modifica di configurazione di dimensioni eccessive per un'istanza 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 pubblica un evento quando valuta le risorse con una frequenza specificata dall'utente (ad esempio ogni 24 ore). Il seguente evento di esempio mostra che la regola è stata attivata con frequenza periodica. ``` { "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" } ``` ------ ### Attributi di eventi L'oggetto JSON per un AWS Config evento contiene i seguenti attributi: `invokingEvent` L'evento che attiva la valutazione di una regola. Se l'evento viene pubblicato in risposta a una modifica di configurazione delle risorse, il valore per questo attributo è una stringa che contiene un JSON `configurationItem` o un `configurationItemSummary` (per gli elementi di configurazione dimensioni eccessive). L'elemento di configurazione rappresenta lo stato della risorsa nel momento in cui è AWS Config stata rilevata la modifica. Per un esempio di elemento di configurazione, vedete l'output prodotto dal `get-resource-config-history` AWS CLI comando in[Visualizzazione della cronologia della configurazione](view-manage-resource-console.md#get-config-history-cli). Se l'evento viene pubblicato per una valutazione periodica, il valore è una stringa che contiene un oggetto JSON. L'oggetto include informazioni sulla valutazione che è stata attivata. Per ogni tipo di evento, una funzione deve analizzare la stringa con un parser JSON per poter valutare il contenuto, come illustrato nel seguente esempio Node.js: ``` var invokingEvent = JSON.parse(event.invokingEvent); ``` `ruleParameters` Coppie chiave-valore che la funzione elabora come parte della sua logica di valutazione. I parametri vengono definiti quando si utilizza la AWS Config console per creare una regola Lambda personalizzata. Puoi anche definire i parametri con l'`InputParameters`attributo nella richiesta `PutConfigRule` AWS Config API o nel `put-config-rule` AWS CLI comando. Il codice JSON per i parametri è contenuto all'interno di una stringa, perciò una funzione deve analizzare la stringa con un parser JSON per essere in grado di valutare il contenuto, come illustrato nel seguente esempio Node.js: ``` var ruleParameters = JSON.parse(event.ruleParameters); ``` `resultToken` Un token a cui la funzione deve passare AWS Config con la `PutEvaluations` chiamata. `eventLeftScope` Un valore booleano che indica se la AWS risorsa da valutare è stata rimossa dall'ambito della regola. Se il valore è `true`, la funzione indica che la valutazione può essere ignorata passando `NOT_APPLICABLE` come valore per l'attributo `ComplianceType` nella chiamata `PutEvaluations`. `executionRoleArn` L'ARN del ruolo IAM a cui è assegnato. AWS Config `configRuleArn` L'ARN AWS Config assegnato alla regola. `configRuleName` Il nome assegnato alla regola che ha causato AWS Config la pubblicazione dell'evento e il richiamo della funzione. `configRuleId` L'ID AWS Config assegnato alla regola. `accountId` L'ID del Account AWS proprietario della regola. `version` Un numero di versione assegnato da AWS. La versione aumenterà se AWS aggiunge attributi agli AWS Config eventi. Se una funzione richiede un attributo solo in eventi che soddisfano o superano una versione specifica, la funzione può controllare il valore dell'attributo. La versione attuale per AWS Config gli eventi è la 1.0. # Gestione delle risorse eliminate per le regole Lambda AWS Config personalizzate Le regole che segnalano le risorse eliminate devono restituire il risultato della valutazione di `NOT_APPLICABLE` per evitare valutazioni non necessarie delle regole. Quando si elimina una risorsa, AWS Config crea `configurationItem` un `ResourceDeleted` valore per`configurationItemStatus`. Puoi utilizzare questi metadati per verificare se una regola segnala una risorsa eliminata. Per ulteriori informazioni sugli elementi di configurazione, consulta [Concetti \$1 Elementi di configurazione](https://docs.aws.amazon.com/config/latest/developerguide/config-concepts.html#config-items.html). Includi i seguenti frammenti di codice per verificare la presenza di risorse eliminate e imposta il risultato della valutazione di una regola lambda AWS Config personalizzata su `NOT_APPLICABLE` se riporta una risorsa eliminata: ------ #### [ 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 le regole gestite e le regole di policy AWS Config personalizzate gestiscono questo comportamento per impostazione predefinita. Se crei una regola lambd AWS Config personalizzata con Python utilizzando AWS Config Development Kit (RDK) AWS Config e Development Kit Library RDKlib (), la classe Evaluator [importata controllerà](https://github.com/awslabs/aws-config-rdklib/blob/master/rdklib/evaluator.py#L56) questo comportamento. Per informazioni su come scrivere regole con RDK e RDKlib, vedete [Writing rules](https://docs.aws.amazon.com/config/latest/developerguide/evaluate-config_components.html#evaluate-config_components_logic) with the RDK and. RDKlib