Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# AWS Config Aturan Kustom
AWS Config Aturan Kustom adalah aturan yang Anda buat dari awal. Ada dua cara untuk membuat aturan AWS Config khusus: dengan fungsi Lambda ([Panduan AWS Lambda Pengembang](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html#gettingstarted-concepts-function)) dan dengan Guard ([Guard GitHub Repository](https://github.com/aws-cloudformation/cloudformation-guard)), sebuah bahasa. policy-as-code
AWS Config *Aturan kustom yang dibuat dengan Lambda disebut Aturan *AWS Config Lambda AWS Config Kustom dan aturan* khusus yang dibuat dengan Guard disebut AWS Config Aturan Kebijakan Kustom.*
Sebelum menggunakan aturan khusus, lihat[Pertimbangan-pertimbangan](evaluate-config.md#evaluate-config-considerations).
## AWS Config Aturan Kebijakan Kustom
Aturan yang ditulis menggunakan Guard dapat dibuat dari AWS Config konsol atau dengan menggunakan AWS Config aturan APIs. AWS Config Aturan Kebijakan Kustom memungkinkan Anda membuat aturan AWS Config Kustom tanpa perlu menggunakan Java atau Python untuk mengembangkan fungsi Lambda untuk mengelola aturan kustom Anda. AWS Config Aturan Kebijakan Kustom dimulai oleh perubahan konfigurasi. Untuk informasi lebih lanjut tentang Guard, lihat [Guard GitHub Repository](https://github.com/aws-cloudformation/cloudformation-guard).
## AWS Config Aturan Lambda Kustom
Aturan Lambda khusus memberi Anda opsi untuk menggunakan Java atau Python untuk membuat fungsi Lambda untuk aturan Kustom. AWS Config *Fungsi Lambda* adalah kode khusus yang Anda unggah AWS Lambda, dan dipanggil oleh peristiwa yang dipublikasikan oleh sumber peristiwa. Jika fungsi Lambda dikaitkan dengan AWS Config aturan, AWS Config memanggilnya saat aturan dimulai. Fungsi Lambda kemudian mengevaluasi informasi konfigurasi yang dikirim oleh AWS Config, dan mengembalikan hasil evaluasi. Untuk informasi selengkapnya tentang fungsi Lambda, lihat [Sumber Fungsi dan Peristiwa](https://docs.aws.amazon.com/lambda/latest/dg/intro-core-components.html) di Panduan *AWS Lambda Pengembang*.
## Perbedaan format untuk Aturan AWS Config Kustom
Tabel berikut menampilkan perbedaan format dalam bidang untuk tipe [ConfigurationItem](https://docs.aws.amazon.com/config/latest/APIReference/API_ConfigurationItem.html)data dan untuk Aturan AWS Config Kustom.
| ConfigurationItem | AWS Config Aturan Kustom |
| --- | --- |
| version | configurationItemVersion |
| accountId | awsAccountId |
| arn | ARN |
| configurationItemMD5Hash | configurationStateMd5Hash |
**Topics**
+ [Aturan Kebijakan Kustom](#evaluate-config_develop-rules-policy)
+ [Aturan Lambda Kustom](#evaluate-config_develop-rules-lambda)
+ [Perbedaan format untuk Aturan AWS Config Kustom](#evaluate-config_develop-schema)
+ [Membuat Aturan Kebijakan Kustom](evaluate-config_develop-rules_cfn-guard.md)
+ [Membuat Aturan Lambda Kustom](evaluate-config_develop-rules_lambda-functions.md)
+ [Mengelola Sumber Daya yang Dihapus untuk Aturan Lambda Kustom](evaluate-config_develop-rules-delete.md)
# Membuat Aturan Kebijakan AWS Config Kustom
Anda dapat membuat aturan Kebijakan AWS Config Kustom dari Konsol Manajemen AWS, AWS CLI, atau AWS Config API.
## Menambahkan aturan Kebijakan AWS Config Kustom
------
#### [ Using the console ]
1. Masuk ke Konsol Manajemen AWS dan buka AWS Config konsol di [https://console.aws.amazon.com/config/rumah](https://console.aws.amazon.com/config/home).
1. Di Konsol Manajemen AWS menu, verifikasi bahwa pemilih Wilayah diatur ke AWS Wilayah yang mendukung AWS Config aturan. Untuk daftar Wilayah yang didukung, lihat [AWS Config Wilayah dan Titik Akhir](https://docs.aws.amazon.com/general/latest/gr/awsconfig.html) di. *Referensi Umum Amazon Web Services*
1. Di navigasi kiri, pilih **Aturan**.
1. Pada halaman **Aturan**, pilih **Tambahkan aturan**.
1. Pada halaman **Tentukan tipe aturan**, pilih **Buat aturan kustom menggunakan Penjaga**.
1. Pada halaman **Konfigurasi aturan**, buat aturan Anda dengan menyelesaikan langkah-langkah berikut:
1. Untuk **nama Aturan**, ketikkan nama unik untuk aturan tersebut.
1. Untuk **Deskripsi**, ketikkan deskripsi untuk aturan.
1. Untuk **versi runtime Guard**, pilih sistem runtime untuk aturan Kebijakan AWS Config Kustom Anda.
1. Untuk **Konten Aturan**, Anda dapat mengisinya dengan kebijakan Guard Custom untuk aturan Anda.
1. Untuk **mode Evaluasi**, pilih kapan dalam proses pembuatan dan manajemen sumber daya Anda AWS Config ingin mengevaluasi sumber daya Anda. Tergantung pada aturan, AWS Config dapat mengevaluasi konfigurasi sumber daya Anda sebelum sumber daya telah disediakan, setelah sumber daya telah ditetapkan, atau keduanya.
1. Pilih **Aktifkan evaluasi proaktif** untuk memungkinkan Anda menjalankan evaluasi pada pengaturan konfigurasi sumber daya Anda sebelum diterapkan.
Setelah mengaktifkan evaluasi proaktif, Anda dapat menggunakan [StartResourceEvaluation](https://docs.aws.amazon.com/config/latest/APIReference/API_StartResourceEvaluation.html)API dan [GetResourceEvaluationSummary](https://docs.aws.amazon.com/config/latest/APIReference/API_GetResourceEvaluationSummary.html)API untuk memeriksa apakah sumber daya yang Anda tentukan dalam perintah ini akan ditandai sebagai NON\$1COMPLIANT oleh aturan proaktif di akun Anda di Wilayah Anda.
Untuk informasi selengkapnya tentang penggunaan perintah ini, lihat [Mengevaluasi Sumber Daya Anda dengan AWS Config Aturan](https://docs.aws.amazon.com/config/latest/developerguide/evaluating-your-resources.html#evaluating-your-resources-proactive). Untuk daftar aturan terkelola yang mendukung evaluasi proaktif, lihat [Daftar Aturan AWS Config Terkelola menurut Mode Evaluasi](https://docs.aws.amazon.com/config/latest/developerguide/managed-rules-by-evaluation-mode.html).
1. Pilih **Aktifkan evaluasi detektif** untuk mengevaluasi pengaturan konfigurasi sumber daya yang ada.
Untuk evaluasi detektif, aturan Kebijakan AWS Config Kustom dimulai oleh perubahan **Konfigurasi**. Opsi ini akan dipilih sebelumnya.
+ **Sumber Daya** — Saat sumber daya yang cocok dengan jenis sumber daya yang ditentukan, atau pengenal tipe plus, dibuat, diubah, atau dihapus.
+ **Tag** — Ketika sumber daya dengan tag yang ditentukan dibuat, diubah, atau dihapus.
+ **Semua perubahan** — Ketika sumber daya yang direkam oleh AWS Config dibuat, diubah, atau dihapus.
AWS Config menjalankan evaluasi saat mendeteksi perubahan pada sumber daya yang cocok dengan cakupan aturan. Anda dapat menggunakan ruang lingkup untuk membatasi sumber daya mana yang memulai evaluasi. Jika tidak, evaluasi dimulai ketika ada perubahan pada sumber daya pasca-penyediaan.
1. Untuk **Parameter**, Anda dapat menyesuaikan nilai untuk kunci yang disediakan jika aturan Anda menyertakan parameter. Parameter adalah atribut yang harus dipatuhi oleh sumber daya Anda sebelum dianggap sesuai dengan aturan.
1. Pada halaman **Tinjau dan buat**, tinjau semua pilihan Anda sebelum menambahkan aturan ke halaman Anda Akun AWS.
1. Setelah selesai meninjau aturan, pilih **Tambahkan aturan**.
------
#### [ Using the AWS CLI ]
Gunakan perintah [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).
`Owner`Bidang harus`CUSTOM_POLICY`. Bidang tambahan berikut diperlukan untuk aturan Kebijakan AWS Config Kustom:
+ `Runtime`: Sistem runtime untuk aturan Kebijakan AWS Config Kustom Anda.
+ `PolicyText`: Definisi kebijakan yang berisi logika untuk aturan Kebijakan AWS Config Kustom Anda.
+ `EnableDebugLogDelivery`: Ekspresi Boolean untuk mengaktifkan logging debug untuk aturan Kebijakan AWS Config Kustom Anda. Nilai default-nya adalah `false`.
------
#### [ Using the API Reference ]
Gunakan [PutConfigRule](https://docs.aws.amazon.com/config/latest/APIReference/API_PutConfigRule.html)tindakan.
`Owner`Bidang harus`CUSTOM_POLICY`. Bidang tambahan berikut diperlukan untuk aturan Kebijakan AWS Config Kustom:
+ `Runtime`: Sistem runtime untuk aturan Kebijakan AWS Config Kustom Anda.
+ `PolicyText`: Definisi kebijakan yang berisi logika untuk aturan Kebijakan AWS Config Kustom Anda.
+ `EnableDebugLogDelivery`: Ekspresi Boolean untuk mengaktifkan logging debug untuk aturan Kebijakan AWS Config Kustom Anda. Nilai default-nya adalah `false`.
------
## Menulis konten aturan untuk aturan Kebijakan AWS Config Kustom
Dengan aturan Kebijakan AWS Config Khusus, Anda dapat menggunakan bahasa khusus domain (DSL) AWS CloudFormation Guard untuk mengevaluasi konfigurasi sumber daya. Topik ini menyediakan pola dan praktik terbaik untuk menulis aturan kebijakan khusus.
Untuk informasi selengkapnya tentang cara menulis aturan dengan Guard, lihat [Menulis aturan Guard](https://docs.aws.amazon.com/cfn-guard/latest/ug/writing-rules.html) di AWS CloudFormation Guard User Guide dan [AWS CloudFormation Guard 2.0 Modes of Operation](https://github.com/aws-cloudformation/cloudformation-guard/tree/main/guard) in the Guard GitHub Repository.
### Struktur aturan dasar
Gunakan format dasar berikut untuk membuat aturan:
```
# 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
}
```
### Komponen kunci
konfigurasi
Berisi isi untuk konfigurasi sumber daya.
SuplementaryConfiguration
Berisi konten tambahan untuk konfigurasi sumber daya. AWS Config mengembalikan bidang ini untuk jenis sumber daya tertentu untuk melengkapi informasi yang dikembalikan untuk bidang konfigurasi.
resourceType
AWS jenis sumber daya yang sedang dievaluasi.
resourceId
ID sumber daya (misalnya,`sg-xxxxxx`).
accountId
Akun AWS ID 12 digit yang terkait dengan sumber daya.
### Pola umum
------
#### [ 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 <>
}}
```
------
### Fitur lanjutan
------
#### [ 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
}
```
------
### Praktik terbaik
+ Gunakan variabel dengan `let` pernyataan untuk meningkatkan keterbacaan.
+ Pemeriksaan terkait grup menggunakan blok aturan bernama.
+ Sertakan komentar deskriptif.
+ Gunakan operator yang sesuai (`exists`,`is_string`,`is_list`).
+ Gunakan pola regex dengan pencocokan case-insensitive.
### Contoh: dynamodb-pitr-enabled
Contoh berikut menunjukkan definisi kebijakan untuk versi aturan Kebijakan AWS Config Kustom dari aturan AWS Config Terkelola[dynamodb-pitr-enabled](dynamodb-pitr-enabled.md). Aturan ini memeriksa apakah tabel Point-in-Time DynamoDB telah mengaktifkan Pemulihan.
```
# 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" <>
}
```
# Membuat Aturan Lambda AWS Config Kustom
Anda dapat mengembangkan aturan khusus dan menambahkannya AWS Config dengan AWS Lambda fungsi.
Anda mengaitkan setiap aturan kustom dengan fungsi Lambda, yang berisi logika yang mengevaluasi apakah AWS sumber daya Anda mematuhi aturan. Anda mengaitkan fungsi ini dengan aturan Anda, dan aturan memanggil fungsi baik sebagai respons terhadap perubahan konfigurasi atau secara berkala. Fungsi tersebut kemudian mengevaluasi apakah sumber daya Anda mematuhi aturan Anda, dan mengirimkan hasil evaluasinya ke AWS Config.
## AWS Kit Pengembangan Aturan (RDK)
AWS Rule Development Kit (RDK) dirancang untuk mendukung alur kerja “Compliance-as-Code” yang intuitif dan produktif. Ini mengabstraksi sebagian besar angkat berat yang tidak berdiferensiasi yang terkait dengan penerapan AWS Config aturan yang didukung oleh fungsi Lambda khusus, dan menyediakan proses iteratif yang efisien. develop-deploy-monitor
Untuk step-by-step instruksi, lihat Dokumentasi [AWS Rule Development Kit (RDK)](https://aws-config-rdk.readthedocs.io/en/master).
## Contoh AWS Lambda Fungsi untuk AWS Config Aturan (Node.js)
AWS Lambda menjalankan fungsi dalam menanggapi peristiwa yang diterbitkan oleh AWS layanan. Fungsi untuk aturan Lambda AWS Config Kustom menerima peristiwa yang diterbitkan oleh AWS Config, dan fungsi tersebut kemudian menggunakan data yang diterimanya dari acara dan diambil dari AWS Config API untuk mengevaluasi kepatuhan aturan. Operasi dalam fungsi untuk aturan Config berbeda tergantung pada apakah ia melakukan evaluasi yang dipicu oleh perubahan konfigurasi atau dipicu secara berkala.
Untuk informasi tentang pola umum dalam AWS Lambda fungsi, lihat [Model Pemrograman](https://docs.aws.amazon.com/lambda/latest/dg/programming-model-v2.html) di *Panduan AWS Lambda Pengembang*.
------
#### [ Example Function for Evaluations Triggered by Configuration Changes ]
AWS Config akan memanggil fungsi seperti contoh berikut ketika mendeteksi perubahan konfigurasi untuk sumber daya yang berada dalam cakupan aturan khusus.
Jika Anda menggunakan AWS Config konsol untuk membuat aturan yang terkait dengan fungsi seperti contoh ini, pilih **Perubahan konfigurasi** sebagai jenis pemicu. Jika Anda menggunakan AWS Config API atau AWS CLI untuk membuat aturan, tetapkan `MessageType` atribut ke `ConfigurationItemChangeNotification` dan`OversizedConfigurationItemChangeNotification`. Pengaturan ini memungkinkan aturan Anda dipicu setiap kali AWS Config menghasilkan item konfigurasi atau item konfigurasi yang terlalu besar sebagai akibat dari perubahan sumber daya.
Contoh ini mengevaluasi sumber daya Anda dan memeriksa apakah instance cocok dengan jenis sumber daya. `AWS::EC2::Instance` Aturan dipicu saat AWS Config menghasilkan item konfigurasi atau pemberitahuan item konfigurasi berukuran besar.
```
'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));
});
};
```
**Operasi Fungsi**
Fungsi melakukan operasi berikut saat runtime:
1. Fungsi berjalan ketika AWS Lambda melewati `event` objek ke `handler` fungsi. Dalam contoh ini, fungsi menerima `callback` parameter opsional, yang digunakan untuk mengembalikan informasi ke pemanggil. AWS Lambda juga melewati `context` objek, yang berisi informasi dan metode yang dapat digunakan fungsi saat berjalan. Perhatikan bahwa dalam versi Lambda yang lebih baru, konteks tidak lagi digunakan.
1. Fungsi memeriksa apakah `messageType` untuk acara tersebut adalah item konfigurasi atau item konfigurasi besar, dan kemudian mengembalikan item konfigurasi.
1. Handler memanggil `isApplicable` fungsi untuk menentukan apakah sumber daya telah dihapus.
**catatan**
Aturan pelaporan sumber daya yang dihapus harus mengembalikan hasil evaluasi untuk menghindari evaluasi aturan yang tidak perlu. `NOT_APPLICABLE`
1. Handler memanggil `evaluateChangeNotificationCompliance` fungsi dan meneruskan `configurationItem` dan `ruleParameters` objek yang AWS Config diterbitkan dalam acara tersebut.
Fungsi pertama mengevaluasi apakah sumber daya adalah instans EC2. Jika sumber daya bukan instans EC2, fungsi mengembalikan nilai kepatuhan. `NOT_APPLICABLE`
Fungsi kemudian mengevaluasi apakah `instanceType` atribut dalam item konfigurasi sama dengan nilai `desiredInstanceType` parameter. Jika nilainya sama, fungsi kembali`COMPLIANT`. Jika nilainya tidak sama, fungsi kembali`NON_COMPLIANT`.
1. Handler bersiap untuk mengirim hasil evaluasi AWS Config dengan menginisialisasi objek. `putEvaluationsRequest` Objek ini mencakup `Evaluations` parameter, yang mengidentifikasi hasil kepatuhan, jenis sumber daya, dan ID sumber daya yang dievaluasi. `putEvaluationsRequest`Objek juga menyertakan token hasil dari acara, yang mengidentifikasi aturan dan acara untuk AWS Config.
1. Handler mengirimkan hasil evaluasi AWS Config dengan meneruskan objek ke `putEvaluations` metode `config` klien.
------
#### [ Example Function for Periodic Evaluations ]
AWS Config akan memanggil fungsi seperti contoh berikut untuk evaluasi berkala. Evaluasi periodik terjadi pada frekuensi yang Anda tentukan saat Anda menentukan aturan di AWS Config.
Jika Anda menggunakan AWS Config konsol untuk membuat aturan yang terkait dengan fungsi seperti contoh ini, pilih **Periodik** sebagai jenis pemicu. Jika Anda menggunakan AWS Config API atau AWS CLI membuat aturan, setel `MessageType` atribut ke`ScheduledNotification`.
Contoh ini memeriksa apakah jumlah total sumber daya tertentu melebihi maksimum yang ditentukan.
```
'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;
}
```
**Operasi Fungsi**
Fungsi melakukan operasi berikut saat runtime:
1. Fungsi berjalan ketika AWS Lambda melewati `event` objek ke `handler` fungsi. Dalam contoh ini, fungsi menerima `callback` parameter opsional, yang digunakan untuk mengembalikan informasi ke pemanggil. AWS Lambda juga melewati `context` objek, yang berisi informasi dan metode yang dapat digunakan fungsi saat berjalan. Perhatikan bahwa dalam versi Lambda yang lebih baru, konteks tidak lagi digunakan.
1. Untuk menghitung sumber daya dari tipe yang ditentukan, handler memanggil `countResourceTypes` fungsi, dan melewati `applicableResourceType` parameter yang diterimanya dari acara tersebut. `countResourceTypes`Fungsi ini memanggil `listDiscoveredResources` metode `config` klien, yang mengembalikan daftar pengidentifikasi untuk sumber daya yang berlaku. Fungsi ini menggunakan panjang daftar ini untuk menentukan jumlah sumber daya yang berlaku, dan mengembalikan hitungan ini ke handler.
1. Handler bersiap untuk mengirim hasil evaluasi AWS Config dengan menginisialisasi objek. `putEvaluationsRequest` Objek ini mencakup `Evaluations` parameter, yang mengidentifikasi hasil kepatuhan dan Akun AWS yang diterbitkan dalam acara tersebut. Anda dapat menggunakan `Evaluations` parameter untuk menerapkan hasilnya ke jenis sumber daya apa pun yang didukung oleh AWS Config. `putEvaluationsRequest`Objek juga menyertakan token hasil dari acara, yang mengidentifikasi aturan dan acara untuk AWS Config.
1. Di dalam `putEvaluationsRequest` objek, handler memanggil `evaluateCompliance` fungsi. Fungsi ini menguji apakah jumlah sumber daya yang berlaku melebihi maksimum yang ditetapkan ke `maxCount` parameter, yang disediakan oleh acara. Jika jumlah sumber daya melebihi maksimum, fungsi kembali`NON_COMPLIANT`. Jika jumlah sumber daya tidak melebihi maksimum, fungsi kembali`COMPLIANT`.
1. Handler mengirimkan hasil evaluasi AWS Config dengan meneruskan objek ke `putEvaluations` metode `config` klien.
------
## Contoh AWS Lambda Fungsi untuk AWS Config Aturan (Python)
AWS Lambda menjalankan fungsi dalam menanggapi peristiwa yang diterbitkan oleh AWS layanan. Fungsi untuk aturan Lambda AWS Config Kustom menerima peristiwa yang diterbitkan oleh AWS Config, dan fungsi tersebut kemudian menggunakan data yang diterimanya dari acara dan diambil dari AWS Config API untuk mengevaluasi kepatuhan aturan. Operasi dalam fungsi untuk aturan Config berbeda tergantung pada apakah ia melakukan evaluasi yang dipicu oleh perubahan konfigurasi atau dipicu secara berkala.
Untuk informasi tentang pola umum dalam AWS Lambda fungsi, lihat [Model Pemrograman](https://docs.aws.amazon.com/lambda/latest/dg/programming-model-v2.html) di *Panduan AWS Lambda Pengembang*.
------
#### [ Example Function for Evaluations Triggered by Configuration Changes ]
AWS Config akan memanggil fungsi seperti contoh berikut ketika mendeteksi perubahan konfigurasi untuk sumber daya yang berada dalam cakupan aturan khusus.
Jika Anda menggunakan AWS Config konsol untuk membuat aturan yang terkait dengan fungsi seperti contoh ini, pilih **Perubahan konfigurasi** sebagai jenis pemicu. Jika Anda menggunakan AWS Config API atau AWS CLI untuk membuat aturan, tetapkan `MessageType` atribut ke `ConfigurationItemChangeNotification` dan`OversizedConfigurationItemChangeNotification`. Pengaturan ini memungkinkan aturan Anda dipicu setiap kali AWS Config menghasilkan item konfigurasi atau item konfigurasi yang terlalu besar sebagai akibat dari perubahan sumber daya.
```
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'])
```
**Operasi Fungsi**
Fungsi melakukan operasi berikut saat runtime:
1. Fungsi berjalan ketika AWS Lambda melewati `event` objek ke `handler` fungsi. Dalam contoh ini, fungsi menerima `callback` parameter opsional, yang digunakan untuk mengembalikan informasi ke pemanggil. AWS Lambda juga melewati `context` objek, yang berisi informasi dan metode yang dapat digunakan fungsi saat berjalan. Perhatikan bahwa dalam versi Lambda yang lebih baru, konteks tidak lagi digunakan.
1. Fungsi memeriksa apakah `messageType` untuk acara tersebut adalah item konfigurasi atau item konfigurasi besar, dan kemudian mengembalikan item konfigurasi.
1. Handler memanggil `isApplicable` fungsi untuk menentukan apakah sumber daya telah dihapus.
**catatan**
Aturan pelaporan sumber daya yang dihapus harus mengembalikan hasil evaluasi untuk menghindari evaluasi aturan yang tidak perlu. `NOT_APPLICABLE`
1. Handler memanggil `evaluateChangeNotificationCompliance` fungsi dan meneruskan `configurationItem` dan `ruleParameters` objek yang AWS Config diterbitkan dalam acara tersebut.
Fungsi pertama mengevaluasi apakah sumber daya adalah instans EC2. Jika sumber daya bukan instans EC2, fungsi mengembalikan nilai kepatuhan. `NOT_APPLICABLE`
Fungsi kemudian mengevaluasi apakah `instanceType` atribut dalam item konfigurasi sama dengan nilai `desiredInstanceType` parameter. Jika nilainya sama, fungsi kembali`COMPLIANT`. Jika nilainya tidak sama, fungsi kembali`NON_COMPLIANT`.
1. Handler bersiap untuk mengirim hasil evaluasi AWS Config dengan menginisialisasi objek. `putEvaluationsRequest` Objek ini mencakup `Evaluations` parameter, yang mengidentifikasi hasil kepatuhan, jenis sumber daya, dan ID sumber daya yang dievaluasi. `putEvaluationsRequest`Objek juga menyertakan token hasil dari acara, yang mengidentifikasi aturan dan acara untuk AWS Config.
1. Handler mengirimkan hasil evaluasi AWS Config dengan meneruskan objek ke `putEvaluations` metode `config` klien.
------
#### [ Example Function for Periodic Evaluations ]
AWS Config akan memanggil fungsi seperti contoh berikut untuk evaluasi berkala. Evaluasi periodik terjadi pada frekuensi yang Anda tentukan saat Anda menentukan aturan di AWS Config.
Jika Anda menggunakan AWS Config konsol untuk membuat aturan yang terkait dengan fungsi seperti contoh ini, pilih **Periodik** sebagai jenis pemicu. Jika Anda menggunakan AWS Config API atau AWS CLI membuat aturan, setel `MessageType` atribut ke`ScheduledNotification`.
```
import botocore
import boto3
import json
import datetime
# Set to True to get the lambda to assume the Role attached on the Config Service (useful for cross-account).
ASSUME_ROLE_MODE = False
DEFAULT_RESOURCE_TYPE = 'AWS::::Account'
# This gets the client after assuming the Config service role
# either in the same AWS account or cross-account.
def get_client(service, event):
"""Return the service boto client. It should be used instead of directly calling the client.
Keyword arguments:
service -- the service name used for calling the boto.client()
event -- the event variable given in the lambda handler
"""
if not ASSUME_ROLE_MODE:
return boto3.client(service)
credentials = get_assume_role_credentials(event["executionRoleArn"])
return boto3.client(service, aws_access_key_id=credentials['AccessKeyId'],
aws_secret_access_key=credentials['SecretAccessKey'],
aws_session_token=credentials['SessionToken']
)
def get_assume_role_credentials(role_arn):
sts_client = boto3.client('sts')
try:
assume_role_response = sts_client.assume_role(RoleArn=role_arn, RoleSessionName="configLambdaExecution")
return assume_role_response['Credentials']
except botocore.exceptions.ClientError as ex:
# Scrub error message for any internal account info leaks
if 'AccessDenied' in ex.response['Error']['Code']:
ex.response['Error']['Message'] = "AWS Config does not have permission to assume the IAM role."
else:
ex.response['Error']['Message'] = "InternalError"
ex.response['Error']['Code'] = "InternalError"
raise ex
# Check whether the message is a ScheduledNotification or not.
def is_scheduled_notification(message_type):
return message_type == 'ScheduledNotification'
def count_resource_types(applicable_resource_type, next_token, count):
resource_identifier = AWS_CONFIG_CLIENT.list_discovered_resources(resourceType=applicable_resource_type, nextToken=next_token)
updated = count + len(resource_identifier['resourceIdentifiers']);
return updated
# Evaluates the configuration items in the snapshot and returns the compliance value to the handler.
def evaluate_compliance(max_count, actual_count):
return 'NON_COMPLIANT' if int(actual_count) > int(max_count) else 'COMPLIANT'
def evaluate_parameters(rule_parameters):
if 'applicableResourceType' not in rule_parameters:
raise ValueError('The parameter with "applicableResourceType" as key must be defined.')
if not rule_parameters['applicableResourceType']:
raise ValueError('The parameter "applicableResourceType" must have a defined value.')
return rule_parameters
# This generate an evaluation for config
def build_evaluation(resource_id, compliance_type, event, resource_type=DEFAULT_RESOURCE_TYPE, annotation=None):
"""Form an evaluation as a dictionary. Usually suited to report on scheduled rules.
Keyword arguments:
resource_id -- the unique id of the resource to report
compliance_type -- either COMPLIANT, NON_COMPLIANT or NOT_APPLICABLE
event -- the event variable given in the lambda handler
resource_type -- the CloudFormation resource type (or AWS::::Account) to report on the rule (default DEFAULT_RESOURCE_TYPE)
annotation -- an annotation to be added to the evaluation (default None)
"""
eval_cc = {}
if annotation:
eval_cc['Annotation'] = annotation
eval_cc['ComplianceResourceType'] = resource_type
eval_cc['ComplianceResourceId'] = resource_id
eval_cc['ComplianceType'] = compliance_type
eval_cc['OrderingTimestamp'] = str(json.loads(event['invokingEvent'])['notificationCreationTime'])
return eval_cc
def lambda_handler(event, context):
global AWS_CONFIG_CLIENT
evaluations = []
rule_parameters = {}
resource_count = 0
max_count = 0
invoking_event = json.loads(event['invokingEvent'])
if 'ruleParameters' in event:
rule_parameters = json.loads(event['ruleParameters'])
valid_rule_parameters = evaluate_parameters(rule_parameters)
compliance_value = 'NOT_APPLICABLE'
AWS_CONFIG_CLIENT = get_client('config', event)
if is_scheduled_notification(invoking_event['messageType']):
result_resource_count = count_resource_types(valid_rule_parameters['applicableResourceType'], '', resource_count)
if valid_rule_parameters.get('maxCount'):
max_count = valid_rule_parameters['maxCount']
compliance_value = evaluate_compliance(max_count, result_resource_count)
evaluations.append(build_evaluation(event['accountId'], compliance_value, event, resource_type=DEFAULT_RESOURCE_TYPE))
response = AWS_CONFIG_CLIENT.put_evaluations(Evaluations=evaluations, ResultToken=event['resultToken'])
```
**Operasi Fungsi**
Fungsi melakukan operasi berikut saat runtime:
1. Fungsi berjalan ketika AWS Lambda melewati `event` objek ke `handler` fungsi. Dalam contoh ini, fungsi menerima `callback` parameter opsional, yang digunakan untuk mengembalikan informasi ke pemanggil. AWS Lambda juga melewati `context` objek, yang berisi informasi dan metode yang dapat digunakan fungsi saat berjalan. Perhatikan bahwa dalam versi Lambda yang lebih baru, konteks tidak lagi digunakan.
1. Untuk menghitung sumber daya dari tipe yang ditentukan, handler memanggil `countResourceTypes` fungsi, dan melewati `applicableResourceType` parameter yang diterimanya dari acara tersebut. `countResourceTypes`Fungsi ini memanggil `listDiscoveredResources` metode `config` klien, yang mengembalikan daftar pengidentifikasi untuk sumber daya yang berlaku. Fungsi ini menggunakan panjang daftar ini untuk menentukan jumlah sumber daya yang berlaku, dan mengembalikan hitungan ini ke handler.
1. Handler bersiap untuk mengirim hasil evaluasi AWS Config dengan menginisialisasi objek. `putEvaluationsRequest` Objek ini mencakup `Evaluations` parameter, yang mengidentifikasi hasil kepatuhan dan Akun AWS yang diterbitkan dalam acara tersebut. Anda dapat menggunakan `Evaluations` parameter untuk menerapkan hasilnya ke jenis sumber daya apa pun yang didukung oleh AWS Config. `putEvaluationsRequest`Objek juga menyertakan token hasil dari acara, yang mengidentifikasi aturan dan acara untuk AWS Config.
1. Di dalam `putEvaluationsRequest` objek, handler memanggil `evaluateCompliance` fungsi. Fungsi ini menguji apakah jumlah sumber daya yang berlaku melebihi maksimum yang ditetapkan ke `maxCount` parameter, yang disediakan oleh acara. Jika jumlah sumber daya melebihi maksimum, fungsi kembali`NON_COMPLIANT`. Jika jumlah sumber daya tidak melebihi maksimum, fungsi kembali`COMPLIANT`.
1. Handler mengirimkan hasil evaluasi AWS Config dengan meneruskan objek ke `putEvaluations` metode `config` klien.
------
## Contoh Acara untuk AWS Config Aturan
Ketika pemicu aturan terjadi, AWS Config memanggil AWS Lambda fungsi aturan dengan menerbitkan peristiwa. Kemudian AWS Lambda mengeksekusi fungsi dengan meneruskan event ke handler fungsi.
------
#### [ Example Event for Evaluations Triggered by Configuration Changes ]
AWS Config menerbitkan peristiwa ketika mendeteksi perubahan konfigurasi untuk sumber daya yang berada dalam lingkup aturan. Contoh peristiwa berikut menunjukkan bahwa aturan dipicu oleh perubahan konfigurasi untuk instans 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 ]
Beberapa perubahan sumber daya menghasilkan item konfigurasi yang terlalu besar. Contoh peristiwa berikut menunjukkan bahwa aturan dipicu oleh perubahan konfigurasi yang terlalu besar untuk instans 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 menerbitkan acara saat mengevaluasi sumber daya Anda pada frekuensi yang Anda tentukan (seperti setiap 24 jam). Contoh peristiwa berikut menunjukkan bahwa aturan dipicu oleh frekuensi periodik.
```
{
"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"
}
```
------
### Atribut Acara
Objek JSON untuk AWS Config acara berisi atribut berikut:
`invokingEvent`
Peristiwa yang memicu evaluasi untuk suatu aturan. Jika acara dipublikasikan sebagai respons terhadap perubahan konfigurasi sumber daya, nilai untuk atribut ini adalah string yang berisi JSON `configurationItem` atau `configurationItemSummary` (untuk item konfigurasi berukuran besar). Item konfigurasi mewakili status sumber daya pada saat AWS Config mendeteksi perubahan. Untuk contoh item konfigurasi, lihat output yang dihasilkan oleh `get-resource-config-history` AWS CLI perintah di[Melihat Riwayat Konfigurasi](view-manage-resource-console.md#get-config-history-cli).
Jika acara diterbitkan untuk evaluasi berkala, nilainya adalah string yang berisi objek JSON. Objek tersebut mencakup informasi tentang evaluasi yang dipicu.
Untuk setiap jenis acara, fungsi harus mengurai string dengan parser JSON untuk dapat mengevaluasi isinya, seperti yang ditunjukkan pada contoh Node.js berikut:
```
var invokingEvent = JSON.parse(event.invokingEvent);
```
`ruleParameters`
Pasangan kunci/nilai yang diproses fungsi sebagai bagian dari logika evaluasinya. Anda menentukan parameter saat menggunakan AWS Config konsol untuk membuat aturan Lambda Kustom. Anda juga dapat menentukan parameter dengan `InputParameters` atribut dalam permintaan `PutConfigRule` AWS Config API atau `put-config-rule` AWS CLI perintah.
Kode JSON untuk parameter terkandung dalam string, sehingga fungsi harus mengurai string dengan parser JSON untuk dapat mengevaluasi isinya, seperti yang ditunjukkan dalam contoh Node.js berikut:
```
var ruleParameters = JSON.parse(event.ruleParameters);
```
`resultToken`
Token yang harus diteruskan oleh fungsi AWS Config dengan `PutEvaluations` panggilan.
`eventLeftScope`
Nilai Boolean yang menunjukkan apakah AWS sumber daya yang akan dievaluasi telah dihapus dari lingkup aturan. Jika nilainya`true`, fungsi menunjukkan bahwa evaluasi dapat diabaikan dengan meneruskan `NOT_APPLICABLE` sebagai nilai untuk `ComplianceType` atribut dalam `PutEvaluations` panggilan.
`executionRoleArn`
ARN dari peran IAM yang ditugaskan untuk. AWS Config
`configRuleArn`
ARN yang AWS Config ditugaskan untuk aturan.
`configRuleName`
Nama yang Anda tetapkan untuk aturan yang menyebabkan AWS Config untuk mempublikasikan acara dan memanggil fungsi.
`configRuleId`
ID yang AWS Config ditetapkan untuk aturan.
`accountId`
ID Akun AWS yang memiliki aturan.
`version`
Nomor versi yang ditetapkan oleh AWS. Versi akan bertambah jika AWS menambahkan atribut ke AWS Config acara. Jika fungsi memerlukan atribut yang hanya dalam peristiwa yang cocok atau melebihi versi tertentu, maka fungsi tersebut dapat memeriksa nilai atribut ini.
Versi saat ini untuk AWS Config acara adalah 1.0.
# Mengelola Sumber Daya yang Dihapus untuk AWS Config Aturan Lambda Kustom
Aturan pelaporan sumber daya yang dihapus harus mengembalikan hasil evaluasi untuk menghindari evaluasi aturan yang tidak perlu. `NOT_APPLICABLE`
Saat Anda menghapus sumber daya, AWS Config buat `configurationItem` dengan `ResourceDeleted` untuk file`configurationItemStatus`. Anda dapat menggunakan metadata ini untuk memeriksa apakah aturan melaporkan sumber daya yang dihapus. Untuk informasi selengkapnya tentang item konfigurasi, lihat [Konsep \$1 Item Konfigurasi](https://docs.aws.amazon.com/config/latest/developerguide/config-concepts.html#config-items.html).
Sertakan cuplikan kode berikut untuk memeriksa sumber daya yang dihapus dan setel hasil evaluasi aturan lambda AWS Config kustom `NOT_APPLICABLE` jika melaporkan sumber daya yang dihapus:
------
#### [ 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
```
------
**catatan**
AWS Config aturan terkelola dan aturan kebijakan AWS Config khusus menangani perilaku ini secara default.
Jika Anda membuat aturan lambd AWS Config kustom dengan Python menggunakan AWS Config Development Kit (RDK) AWS Config dan Development Kit Library RDKlib (), class Evaluator yang [diimpor akan memeriksa](https://github.com/awslabs/aws-config-rdklib/blob/master/rdklib/evaluator.py#L56) perilaku ini. Untuk informasi tentang cara menulis aturan dengan RDK dan RDKlib, lihat [Menulis aturan dengan RDK](https://docs.aws.amazon.com/config/latest/developerguide/evaluate-config_components.html#evaluate-config_components_logic) dan. RDKlib