Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Contoh kebijakan temporal
<a name="example-policies-temporal"></a>

Kebijakan di bagian ini memutuskan dari apa yang telah terjadi sebelumnya di sesi yang sama. Mereka membiarkan Anda memerlukan persetujuan sebelum pembayaran, kedaluwarsa izin yang sudah basi, membatasi total yang berjalan, atau memblokir tindakan setelah kegagalan. Tidak ada permintaan tunggal yang membawa informasi yang cukup untuk memutuskan semua ini.

Setiap contoh mengotorisasi gateway referensi yang dijelaskan dalam [konfigurasi Resource untuk contoh](example-policies-reference.md). Untuk skema acara temporal, operator, ID sesi, kuota, dan ketersediaan Wilayah, lihat Kebijakan sementara dan [Penulisan [kebijakan temporal](policy-temporal.md).](policy-temporal-authoring.md)

## Sebelum Anda menggunakan contoh-contoh ini
<a name="example-policies-temporal-before"></a>

Empat hal menentukan apakah kebijakan temporal berperilaku seperti yang Anda harapkan.

 **ID sesi diperlukan**   
Sejarah temporal mencakup sesi yang Anda sebutkan. Kirim ID sesi di `x-amzn-bedrock-agentcore-policy-session-id` header pada setiap permintaan, dimulai dengan yang pertama. Gateway tidak menghasilkan satu untuk Anda, dan jika mesin memegang kebijakan temporal, permintaan tanpa ID sesi gagal validasi.

 **Hanya tindakan yang diizinkan menjadi `response` peristiwa**   
Tindakan mencatat `response` peristiwa hanya jika kebijakan mengizinkannya dan selesai. Tindakan yang ditolak merekam suatu `error` peristiwa sebagai gantinya. Jadi masing-masing contoh berikut membutuhkan penjelasan yang jelas `permit` untuk tindakan prasyarat juga — jika tidak prasyarat ditolak, tidak pernah dicatat sebagai a`response`, dan kondisi temporal tidak akan pernah bisa menandingi. Setiap contoh menyatakan yang memungkinkan untuk memasangkannya dengan.

 **`eventResource: resource`adalah wajib**   
Setiap predikat harus menyertakan`eventResource: resource`, yang menghubungkan peristiwa yang cocok dengan sumber daya dalam lingkup kebijakan. Menghilangkan itu ditolak dengan`temporal predicates do not constrain the matched event to the current request’s resource`. Anda tidak perlu menulis `sessionId` — skema acara sudah mencakup setiap predikat untuk sesi saat ini.

 **Perbandingan yang diurutkan membutuhkan bilangan bulat; kesetaraan tidak**   
Di dalam `temporal { }` blok, dua jenis perbandingan menerima jenis yang berbeda.  
+  **Memesan** — `<``⇐`,`>`,, `>=` — membutuhkan `integer` di kedua sisi. A `decimal` atau a `string` ditolak saat Anda membuat kebijakan, dengan`comparison requires numeric operands on both sides`.
+  **Kesetaraan** — `==` dan `!=` — bekerja pada jenis apa pun, selama kedua belah pihak adalah tipe yang sama. Inilah yang digunakan korelasi: pencocokan `input.claimId` terhadap `context.input.claimId` membandingkan dua string, yang didukung.
Jadi modelkan nilai apa pun yang dimiliki kebijakan temporal hingga **total atau ambang batas** sebagai`integer`. Inilah sebabnya mengapa gateway referensi menyatakan uang dalam unit minor integer pada alat agregat contoh ini. Penjumlahan memiliki persyaratan yang sama dan pesannya sendiri: `sum` membutuhkan `integer` ringkasan. Untuk informasi selengkapnya, lihat [Jenis parameter dalam kondisi](example-policies-reference.md#example-policies-types).

## Memerlukan persetujuan sebelumnya untuk klaim yang sama
<a name="example-policies-temporal-integrity"></a>

 **Maksud:** Izinkan pembayaran yang akan dicairkan hanya untuk klaim yang disetujui di awal sesi, sehingga agen tidak dapat mencairkan terhadap ID klaim yang dibuatnya.

`::response`Predikat cocok dengan yang sudah selesai`approve_claim`. Berkorelasi `output.claimId` dengan permintaan saat ini `context.input.claimId` adalah apa yang mengikat pencairan dengan persetujuan khusus itu - tanpa korelasi, persetujuan apa pun dalam sesi akan mengizinkan pembayaran atas klaim apa pun.

```
permit (
    principal,
    action == AgentCore::Action::"InsuranceAPI___disburse_payment",
    resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:us-west-2:123456789012:gateway/insurance-gw-a1b2c3d4e5"
)
when temporal {
    formerly within 1h AgentCore::Action::"InsuranceAPI___approve_claim"::response{
        eventResource: resource,
        output.claimId: context.input.claimId
    }
};
```

**penting**  
 `output.*`bidang ada pada `response` acara hanya ketika target mendeklarasikan skema keluaran untuk alat tersebut. Banyak target tidak — target Lambda, misalnya, biasanya mendeklarasikan input saja, dan kemudian acara tersebut hanya membawa,`eventPrincipal`,,`eventResource`, `input.*` dan. `requestId` `sessionId`  
**Jika Anda memberi nama bidang yang tidak dideklarasikan oleh acara, layanan akan menolak kebijakan dan kesalahan mencantumkan apa yang tersedia:**  

```
predicate `AgentCore::Action::"MyTarget___verify_purchase"::response` mentions field
`output.orderId`, which is not declared on that event (declared fields: eventPrincipal,
eventResource, input.orderId, requestId, sessionId)
```
Gunakan daftar itu untuk melihat apa yang dapat Anda korelasikan. Jika tidak ada bidang keluaran, korelasikan pada bidang **input** bersama — `input.claimId: context.input.claimId` mengikat dua panggilan ke klaim yang sama tanpa memerlukan alat sebelumnya untuk mengembalikan apa pun.  
Keduanya tidak setara, jadi pilihlah dengan sengaja. **Korelasi input cocok dengan apa yang **diminta** panggilan sebelumnya; korelasi keluaran cocok dengan apa yang dikembalikan.** Jika aturan Anda bergantung pada nilai yang dihasilkan alat sebelumnya — ID persetujuan, jumlah yang dihitung — hanya korelasi keluaran yang memaksanya, dan itu mengharuskan target untuk mendeklarasikan skema keluaran.

Pasangkan ini dengan izin biasa sehingga persetujuan diizinkan dan dicatat:

```
permit (
    principal,
    action == AgentCore::Action::"InsuranceAPI___approve_claim",
    resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:us-west-2:123456789012:gateway/insurance-gw-a1b2c3d4e5"
);
```


| Permintaan urutan dalam sesi | Keputusan | 
| --- | --- | 
|  `disburse_payment`tanpa persetujuan sebelumnya | DENY | 
|  `approve_claim`untuk klaim, maka `disburse_payment` untuk klaim yang sama | IZINKAN | 
|  `approve_claim`untuk satu klaim, maka `disburse_payment` untuk klaim yang berbeda | DENY | 

## Membutuhkan tindakan prasyarat
<a name="example-policies-temporal-sequencing"></a>

 **Maksud:** Izinkan klaim disetujui hanya setelah seseorang melihat statusnya di sesi.

Pencocokan `::request` berarti prasyarat hanya harus **dicoba**, bukan untuk berhasil. Pasangkan dengan izin untuk`get_claim_status`.

```
permit (
    principal,
    action == AgentCore::Action::"InsuranceAPI___approve_claim",
    resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:us-west-2:123456789012:gateway/insurance-gw-a1b2c3d4e5"
)
when temporal {
    formerly within 5m AgentCore::Action::"InsuranceAPI___get_claim_status"::request{
        eventResource: resource
    }
};
```

## Membutuhkan a **sukses** prasyarat, baru-baru ini
<a name="example-policies-temporal-freshness"></a>

 **Maksud:** Izinkan persetujuan hanya jika pencarian status **selesai** dalam lima menit terakhir, sehingga pencarian basi berhenti memberikan izin.

Satu-satunya perubahan dari contoh sebelumnya adalah `::response` menggantikan`::request`, dan itu adalah perbedaan antara “dicoba” dan “berhasil”. Panjang jendela menentukan seberapa segar kesuksesan itu; setelah berlalu, izin hilang sampai prasyarat berjalan lagi.

```
permit (
    principal,
    action == AgentCore::Action::"InsuranceAPI___approve_claim",
    resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:us-west-2:123456789012:gateway/insurance-gw-a1b2c3d4e5"
)
when temporal {
    formerly within 5m AgentCore::Action::"InsuranceAPI___get_claim_status"::response{
        eventResource: resource
    }
};
```


| Permintaan urutan dalam sesi | Keputusan | 
| --- | --- | 
|  `approve_claim`sebelum pencarian selesai | DENY | 
| pencarian selesai, lalu di `approve_claim` dalam jendela | IZINKAN | 
|  `approve_claim`setelah jendela berlalu | DENY | 

## Tutup berapa kali tindakan berjalan
<a name="example-policies-temporal-rate-limit"></a>

 **Maksud:** Izinkan paling banyak tiga pencairan dalam rentang lima menit sesi.

 `count`menghitung peristiwa yang cocok di jendela, termasuk permintaan yang diotorisasi, jadi panggilan keempat di jendela adalah yang pertama ditolak. `exists (n: Long)`Pengikat menangkap hitungan sehingga `n > 3` filter dapat mengujinya; agregat membutuhkan tanda kurung di sebelah kiri. `==` Pasangkan dengan izin untuk `disburse_payment` sehingga panggilan diizinkan hingga batas.

```
forbid (
    principal,
    action == AgentCore::Action::"InsuranceAPI___disburse_payment",
    resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:us-west-2:123456789012:gateway/insurance-gw-a1b2c3d4e5"
)
when temporal {
    exists (n: Long).
        (count for (t: Timepoint).
            where (formerly within 5m (AgentCore::Action::"InsuranceAPI___disburse_payment"::request{ eventResource: resource } && tp(t)))) == n
        && n > 3
};
```

**penting**  
Ini bukan kontrol keamanan. Penelepon menyediakan ID sesi, sehingga mereka dapat mengatur ulang hitungan dengan memulai sesi baru. Gunakan untuk membentuk perilaku di dalam sesi kooperatif — untuk menghentikan agen perulangan, misalnya — untuk tidak memberlakukan batasan terhadap penelepon yang mengontrol ID sesi mereka sendiri. Untuk informasi selengkapnya, lihat [Pertimbangan keamanan](policy-temporal.md#policy-temporal-security).

## Tutup total yang sedang berjalan
<a name="example-policies-temporal-budget"></a>

 **Maksud:** Izinkan pencairan hingga totalnya 3.000,00 dalam waktu lima menit, lalu berhenti.

 `sum`menambahkan bidang input bernama di seluruh peristiwa yang cocok, termasuk permintaan saat ini, sehingga permintaan yang akan melewati ambang batas adalah yang ditolak. Dengan batas 300.000 sen dan pencairan 100000, dua yang pertama diizinkan dan yang ketiga ditolak.

```
forbid (
    principal,
    action == AgentCore::Action::"InsuranceAPI___disburse_payment",
    resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:us-west-2:123456789012:gateway/insurance-gw-a1b2c3d4e5"
)
when temporal {
    exists (total: Long).
        (sum amt for (amt: Long), (t: Timepoint).
            where (formerly within 5m (AgentCore::Action::"InsuranceAPI___disburse_payment"::request{ eventResource: resource, input.amountCents: amt } && tp(t)))) == total
        && total >= 300000
};
```

Domain dua variabel,`for (amt: Long), (t: Timepoint)`, diperlukan: `amt` adalah nilai yang dijumlahkan dan `t` membedakan titik waktu, sehingga dua pencairan dengan jumlah yang sama dihitung dua kali daripada dideduplikasi menjadi satu.

**catatan**  
 `amountCents`adalah skema `integer` dalam alat, dan itulah yang membuat kebijakan ini berfungsi. `sum`Agregasi membutuhkan bilangan bulat summand, dan perbandingan pengurutan `total` membutuhkan bilangan bulat di kedua sisi, sehingga bidang yang dinyatakan skema Anda sebagai `number` tidak dapat mendorong batas seperti ini. Untuk aturan tipe yang bergantung pada contoh ini, lihat [Sebelum Anda menggunakan contoh ini](#example-policies-temporal-before).

## Jadikan setiap persetujuan baik untuk satu penggunaan
<a name="example-policies-temporal-one-time"></a>

 **Maksud:** Izinkan satu pencairan per persetujuan. Setelah pembayaran, membutuhkan persetujuan baru.

`since`Operator memegang ketika jangkar di sebelah kanannya terjadi di dalam jendela dan kondisi di sebelah kirinya terus menerus sejak saat itu. Di sini berbunyi: persetujuan selesai dalam satu jam terakhir, dan tidak ada pencairan yang diselesaikan sejak itu. Pembayaran pertama setelah persetujuan menghabiskannya.

```
permit (
    principal,
    action == AgentCore::Action::"InsuranceAPI___disburse_payment",
    resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:us-west-2:123456789012:gateway/insurance-gw-a1b2c3d4e5"
)
when temporal {
    !AgentCore::Action::"InsuranceAPI___disburse_payment"::response{ eventResource: resource }
    since within 1h AgentCore::Action::"InsuranceAPI___approve_claim"::response{ eventResource: resource }
};
```

Pencocokan `::response` di sisi yang dinegasikan sangat penting. Permintaan yang diotorisasi belum menghasilkan respons, sehingga tidak memblokir dirinya sendiri — pencocokan `::request` di sana akan membuat setiap pencairan menyangkal dirinya sendiri.


| Permintaan urutan dalam sesi | Keputusan | 
| --- | --- | 
|  `approve_claim`, maka `disburse_payment`  | IZINKAN | 
| detik `disburse_payment` tanpa persetujuan baru | DENY | 
| yang baru`approve_claim`, maka `disburse_payment`  | IZINKAN | 

**catatan**  
Sebuah `response` peristiwa direkam tak lama setelah panggilan selesai. Tunggu persetujuan kembali sebelum mengeluarkan pencairan daripada mengirimnya kembali ke belakang. Untuk informasi selengkapnya, lihat [Mengurutkan tindakan yang bergantung pada respons sebelumnya](policy-temporal.md#policy-temporal-response-delay).

## Menegakkan pendinginan
<a name="example-policies-temporal-cooldown"></a>

 **Maksud:** Mencegah tindakan yang sama agar tidak berulang dalam satu menit setelah selesai.

Kondisi ini mengacu pada tindakan yang sama yang diotorisasi. `::response`inilah yang membuatnya aman: permintaan saat ini belum memiliki respons, jadi tidak cocok dengan dirinya sendiri. Ditulis dengan`::request`, permintaan saat ini akan cocok dengan acaranya sendiri dan tindakan akan dilarang secara permanen. Untuk informasi selengkapnya, lihat [Self-referential ketentuan yang menyertakan permintaan saat ini](policy-temporal.md#policy-temporal-self-referential).

```
forbid (
    principal,
    action == AgentCore::Action::"InsuranceAPI___disburse_payment",
    resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:us-west-2:123456789012:gateway/insurance-gw-a1b2c3d4e5"
)
when temporal {
    formerly within 1m AgentCore::Action::"InsuranceAPI___disburse_payment"::response{
        eventResource: resource
    }
};
```

## Memerlukan prasyarat yang belum dibatalkan
<a name="example-policies-temporal-precondition"></a>

 **Maksud:** Izinkan pencairan sementara persetujuan berdiri, dan tarik izin jika klaim dibuka kembali untuk peninjauan status sesudahnya.

Ini memiliki bentuk yang sama dengan persetujuan sekali pakai, tetapi tindakan yang dinegasikan berbeda dari tindakan yang diotorisasi, yang mengubah “konsumsi persetujuan” menjadi “membatalkan persetujuan”. Izin hibah untuk keduanya `approve_claim` dan`get_claim_status`.

```
permit (
    principal,
    action == AgentCore::Action::"InsuranceAPI___disburse_payment",
    resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:us-west-2:123456789012:gateway/insurance-gw-a1b2c3d4e5"
)
when temporal {
    !AgentCore::Action::"InsuranceAPI___get_claim_status"::response{ eventResource: resource }
    since within 5m AgentCore::Action::"InsuranceAPI___approve_claim"::response{ eventResource: resource }
};
```


| Permintaan urutan dalam sesi | Keputusan | 
| --- | --- | 
|  `disburse_payment`sebelum persetujuan apa pun | DENY | 
|  `approve_claim`, maka `disburse_payment`  | IZINKAN | 
|  `get_claim_status`terjadi, maka `disburse_payment`  | DENY | 
| yang baru`approve_claim`, maka `disburse_payment`  | IZINKAN | 

## Membutuhkan rantai tindakan secara berurutan
<a name="example-policies-temporal-chain"></a>

 **Maksud:** Memerlukan pencarian status urutan, lalu persetujuan, lalu pencairan.

Satu kebijakan per tautan, dan rantai muncul dari komposisi mereka. Berikan izin biasa untuk tindakan pertama sehingga rantai dapat dimulai. Langkah yang dicoba rusak ditolak sampai prasyaratnya selesai.

```
// Link 1: approve only after a completed status lookup
permit (
    principal,
    action == AgentCore::Action::"InsuranceAPI___approve_claim",
    resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:us-west-2:123456789012:gateway/insurance-gw-a1b2c3d4e5"
)
when temporal {
    formerly within 5m AgentCore::Action::"InsuranceAPI___get_claim_status"::response{ eventResource: resource }
};

// Link 2: disburse only after a completed approval
permit (
    principal,
    action == AgentCore::Action::"InsuranceAPI___disburse_payment",
    resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:us-west-2:123456789012:gateway/insurance-gw-a1b2c3d4e5"
)
when temporal {
    formerly within 5m AgentCore::Action::"InsuranceAPI___approve_claim"::response{ eventResource: resource }
};
```

## Membutuhkan dua prasyarat dalam urutan apa pun
<a name="example-policies-temporal-parallel"></a>

 **Maksud:** Izinkan pencairan hanya setelah pencarian status dan persetujuan selesai, dalam kedua urutan.

Dua `formerly` kondisi yang bergabung dengan `&&` membutuhkan keduanya, dan tidak ada yang membatasi pesanan. Ini menggunakan dua dari tiga operator temporal yang mungkin berisi satu kebijakan.

```
permit (
    principal,
    action == AgentCore::Action::"InsuranceAPI___disburse_payment",
    resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:us-west-2:123456789012:gateway/insurance-gw-a1b2c3d4e5"
)
when temporal {
    formerly within 1h AgentCore::Action::"InsuranceAPI___get_claim_status"::response{ eventResource: resource }
    && formerly within 1h AgentCore::Action::"InsuranceAPI___approve_claim"::response{ eventResource: resource }
};
```

## Buat dua tindakan yang saling eksklusif
<a name="example-policies-temporal-mutex"></a>

 **Maksud:** Dalam waktu dua menit, izinkan pencairan atau penghapusan klaim, tetapi tidak keduanya.

Pengecualian membutuhkan dua kebijakan simetris, satu per arah; satu hanya `forbid` akan memblokir satu pesanan. Pencocokan `::request` berarti hanya **mencoba** satu tindakan memblokir yang lain, tanpa menunggu sampai selesai.

```
// Forbid deletion if a disbursement was requested within 2m
forbid (
    principal,
    action == AgentCore::Action::"InsuranceAPI___delete_claim",
    resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:us-west-2:123456789012:gateway/insurance-gw-a1b2c3d4e5"
)
when temporal {
    formerly within 2m AgentCore::Action::"InsuranceAPI___disburse_payment"::request{ eventResource: resource }
};

// Forbid disbursement if a deletion was requested within 2m
forbid (
    principal,
    action == AgentCore::Action::"InsuranceAPI___disburse_payment",
    resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:us-west-2:123456789012:gateway/insurance-gw-a1b2c3d4e5"
)
when temporal {
    formerly within 2m AgentCore::Action::"InsuranceAPI___delete_claim"::request{ eventResource: resource }
};
```

## Membutuhkan jumlah ambang peristiwa
<a name="example-policies-temporal-threshold"></a>

 **Maksud:** Izinkan klaim dihapus hanya setelah setidaknya dua pencairan selesai terhadapnya.

Berkorelasi `input.claimId` dengan klaim permintaan saat ini mencakup hitungan untuk klaim itu daripada menghitung setiap pencairan dalam sesi.

```
permit (
    principal,
    action == AgentCore::Action::"InsuranceAPI___delete_claim",
    resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:us-west-2:123456789012:gateway/insurance-gw-a1b2c3d4e5"
)
when temporal {
    exists (n: Long).
        (count for (t: Timepoint).
            where (formerly within 5m (AgentCore::Action::"InsuranceAPI___disburse_payment"::response{ eventResource: resource, input.claimId: context.input.claimId } && tp(t)))) == n
        && n >= 2
};
```

**catatan**  
 `count`menghitung peristiwa, bukan penelepon yang berbeda. Itu tidak dapat mengungkapkan “disetujui oleh dua orang yang berbeda”, karena tidak ada yang menghentikan satu prinsipal dari memproduksi semua peristiwa yang cocok. Untuk persetujuan multi-pihak, berkorelasi pada `eventPrincipal` atau menegakkan perbedaan kebijakan di luar.

## Blokir tindakan setelah penolakan sebelumnya
<a name="example-policies-temporal-after-denial"></a>

 **Maksud:** Hentikan sesi dari pencairan setelah upaya persetujuan apa pun ditolak.

`error`Peristiwa mencatat permintaan yang ditolak atau gagal, demikian `::error` juga bagaimana kebijakan bereaksi terhadap kegagalan sebelumnya. Pasangkan ini dengan izin biasa `disburse_payment` sehingga diperbolehkan dalam kondisi normal.

```
forbid (
    principal,
    action == AgentCore::Action::"InsuranceAPI___disburse_payment",
    resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:us-west-2:123456789012:gateway/insurance-gw-a1b2c3d4e5"
)
when temporal {
    formerly within 3m AgentCore::Action::"InsuranceAPI___approve_claim"::error{
        eventResource: resource
    }
};
```

Ini adalah pola penahanan yang berguna: agen yang menyelidiki izin yang tidak dimilikinya terputus dari tindakan sensitif daripada diizinkan untuk terus mencoba.

## Gabungkan kondisi temporal, pagar pembatas, dan permintaan
<a name="example-policies-temporal-mixed"></a>

 **Maksud:** Izinkan penelepon untuk mengajukan klaim, asalkan sesi memiliki kurang dari tiga pengajuan dalam 24 jam terakhir, deskripsi klaim tidak membawa rincian bank, dan penelepon bukan peran terbatas.

Ketiga jenis kondisi disusun dalam satu kebijakan, dan setiap klausa harus berlaku `permit` untuk diterapkan. `temporal`Blok memberlakukan batas, `when` blok menyaring konten, dan `unless` blok mengecualikan peran. Masing-masing dievaluasi secara independen.

```
permit (
    principal is AgentCore::OAuthUser,
    action == AgentCore::Action::"InsuranceAPI___file_claim",
    resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:us-west-2:123456789012:gateway/insurance-gw-a1b2c3d4e5"
)
when temporal {
    exists (n: Long).
        (count for (t: Timepoint).
            where (formerly within 24h (AgentCore::Action::"InsuranceAPI___file_claim"::request{ eventResource: resource } && tp(t)))) == n
        && n <= 3
}
when {
    BedrockGuardrails::SensitiveInformation(["US_BANK_ACCOUNT_NUMBER"], [context.input.description]).count() == 0
}
unless {
    principal.hasTag("role") &&
    principal.getTag("role") == "restricted"
};
```

Layar pagar pembatas`description`, yang merupakan satu-satunya parameter teks bebas yang dibutuhkan. `file_claim` Arahkan pagar pembatas informasi sensitif ke bidang yang dapat membawa data yang Anda skrining dengan masuk akal. Jika Anda mengarahkannya ke pengidentifikasi atau nomor, ia tidak memiliki apa pun untuk dideteksi dan klausa diam-diam lewat. `description`bersifat opsional, jadi permintaan yang menghilangkannya tidak memberikan teks pada pagar pembatas dan klausa berlaku.

## Apa yang berubah saat Anda mengedit kebijakan temporal
<a name="example-policies-temporal-invalidation"></a>

Menambahkan atau memperbarui kebijakan temporal pada mesin membatalkan sesi temporal terbuka mesin itu, karena riwayat yang direkam tidak lagi cocok dengan aturan yang diterapkan padanya. Permintaan berikutnya yang menggunakan kembali sesi yang tidak valid gagal dengan HTTP 409. `ConflictException` Mulai sesi baru dan coba lagi; sesi baru dimulai dengan riwayat kosong dan dievaluasi terhadap kebijakan yang diperbarui.

**penting**  
Rencanakan ini ketika Anda meluncurkan perubahan kebijakan sementara. Klien perlu memperlakukan a `409` sebagai “memulai sesi baru”. Alur kerja multi-langkah dalam penerbangan dimulai ulang daripada dilanjutkan.