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à.
# 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.