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

Menulis kebijakan temporal

Anda membuat kebijakan temporal dalam bahasa kebijakan Dogwood dan menambahkannya ke mesin kebijakan, dengan cara yang sama Anda membuat kebijakan lain untuk Kebijakan di AgentCore. Kebijakan temporal adalah forbid aturan permit atau yang kondisi sadar sesi ditempatkan dalam satu temporal blok; prinsip, tindakan, dan sumber daya yang berlaku aturan ditulis menggunakan cak (principal, action, resource) upan standar, sama seperti kebijakan lainnya. Bagian berikut menunjukkan cara membuat kebijakan temporal dan menelusuri pola umum yang dapat Anda ekspresikan.

Buat kebijakan temporal

Anda membuat kebijakan temporal dengan create-policy operasi, operasi yang sama yang Anda gunakan untuk kebijakan lain, dan melampirkannya ke mesin kebijakan. Pernyataan kebijakan temporal termasuk policy dalam definisi, bukan di bawah cedar kebijakan Cedar tanpa kewarganegaraan.

Contoh AWS CLI berikut membuat kebijakan temporal pada mesin kebijakan:

aws bedrock-agentcore-control create-policy \
  --policy-engine-id my-policy-engine-id \
  --name TransferToLookedUpAccount \
  --validation-mode FAIL_ON_ANY_FINDINGS \
  --definition '{
    "policy": {
      "statement": "permit (principal, action == AgentCore::Action::\"FundsTarget___transfer_funds\", resource == AgentCore::Gateway::\"arn:aws:bedrock-agentcore:us-west-2:123456789012:gateway/my-gateway\") when temporal { formerly within 1h AgentCore::Action::\"FundsTarget___get_account_balance\"::response{ eventResource: resource, output.accountId: context.input.toAccount } };"
    }
  }'

Anda juga dapat membuat kebijakan temporal dengan menggambarkannya dalam bahasa alami alih-alih menulis pernyataan Dogwood sendiri.

Skema acara: bidang yang dapat Anda referensikan

Kondisi di dalam temporal { } blok menggunakan predikat peristiwa temporal untuk mencocokkan peristiwa tertentu yang direkam dalam sesi sejauh ini (hingga dan termasuk tindakan yang saat ini sedang diotorisasi). Predikat menamai jendela waktu, jenis tindakan dan peristiwa, dan serangkaian batasan bidang pada peristiwa yang cocok. create-policyContoh di bagian sebelumnya menggunakan satu predikat,formerly within 1h AgentCore::Action::"FundsTarget___get_account_balance"::response{ eventResource: resource, output.accountId: context.input.toAccount }, yang cocok dengan rekaman get_account_balance response dalam satu jam terakhir yang sama output.accountId dengan permintaan toAccount saat ini.

Untuk menulis predikat, Anda perlu mengetahui peristiwa mana yang dihasilkan suatu tindakan dan bidang mana yang dibawa setiap peristiwa, karena itu adalah bidang yang dapat dibatasi dan berkorelasi dengan predikat. Bagian ini menjelaskan skema peristiwa itu.

Setiap tindakan menghasilkan hingga tiga jenis peristiwa, dinamai sesuai jenis peristiwa dalam predikat (::request,::response,::error):

Skema peristiwa temporal mendefinisikan peristiwa ini untuk setiap tindakanA. …​inputs(A)dan …​outputs(A) memperluas ke bidang input dan output yang dinyatakan tindakan:

// Recorded for each authorized request.
decision event <A>::request {
    ...inputs(A),
    eventPrincipal: principalType(A),
    eventResource:  resourceType(A),
    requestId:      String,
    pin sessionId:  String = context.sessionId,
}

// Recorded when the tool returns successfully; carries inputs and outputs.
event <A>::response {
    ...inputs(A),
    ...outputs(A),
    eventPrincipal: principalType(A),
    eventResource:  resourceType(A),
    requestId:      String,
    pin sessionId:  String = context.sessionId,
}

// Recorded when the request is denied or the tool returns an error; history-only.
event <A>::error {
    ...inputs(A),
    eventPrincipal: principalType(A),
    eventResource:  resourceType(A),
    requestId:      String,
    pin sessionId:  String = context.sessionId,
}

Dalam badan predikat, Anda dapat mereferensikan bidang berikut dari peristiwa yang cocok:

Untuk menghubungkan peristiwa yang direkam dengan permintaan saat ini, bandingkan salah satu bidang ini dengan nilai dari permintaan saat ini, seperticontext.input.<name>.

Kasus penggunaan

Berikut ini adalah beberapa contoh kebijakan temporal.

Alat yang tersedia

Contoh di bagian ini menggunakan target gateway bernama FundsTarget yang mengekspos tiga alat. Dalam kebijakan, setiap alat direferensikan oleh nama tindakannyaFundsTarget___<tool-name>, dan oleh bidang input dan output yang tercantum di sini.

Contoh: integritas output-ke-input

Contoh ini memungkinkan agen mentransfer dana hanya ke akun yang dicari sebelumnya di sesi yang sama, mencegahnya mentransfer ke akun yang dibuatnya. Kebijakan transfer_funds hanya mengizinkan ketika get_account_balance respons sebelumnya di sesi mengembalikan akun yang sama:

permit (
    principal,
    action == AgentCore::Action::"FundsTarget___transfer_funds",
    resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:us-west-2:123456789012:gateway/my-gateway"
)
when temporal {
    formerly within 1h AgentCore::Action::"FundsTarget___get_account_balance"::response{
        eventResource: resource,
        output.accountId: context.input.toAccount
    }
};

P ::response redikat cocok dengan respons yang direkam dari sebelumnyaget_account_balance. output.accountIdadalah bidang yang dikembalikan alat, dan context.input.toAccount merupakan akun tujuan pada transfer_funds permintaan saat ini; mengharuskannya untuk sama menghubungkan transfer ke pencarian sebelumnya.

Karena mesin kebijakan menolak secara default, dan karena tindakan dicatat sebagai response hanya jika diizinkan, Anda juga memberikan plain permit for get_account_balance sehingga pencarian diizinkan dan dicatat sebagai respons dalam sesi:

permit (
    principal,
    action == AgentCore::Action::"FundsTarget___get_account_balance",
    resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:us-west-2:123456789012:gateway/my-gateway"
);

Dengan kedua kebijakan tersebut, permintaan dalam sesi diputuskan sebagai berikut:

Contoh: pengurutan alat

Contoh ini mengizinkan tindakan hanya setelah tindakan prasyarat dijalankan sebelumnya di sesi yang sama. Kebijakan berikut get_account_balance hanya mengizinkan jika transfer_funds permintaan terjadi dalam lima menit terakhir:

permit (
    principal,
    action == AgentCore::Action::"FundsTarget___get_account_balance",
    resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:us-west-2:123456789012:gateway/my-gateway"
)
when temporal {
    formerly within 5m AgentCore::Action::"FundsTarget___transfer_funds"::request{
        eventResource: resource
    }
};

P ::request redikat cocok dengan transfer_funds permintaan sebelumnya dalam sesi. Pasangkan ini dengan permit for transfer_funds sehingga tindakan diizinkan dan direkam. Dengan kedua kebijakan di tempatnya, get_account_balance ditolak sampai a transfer_funds telah berjalan dalam sesi:

Contoh: kesegaran data

Contoh ini mengizinkan tindakan hanya jika prasyarat berhasil diselesaikan dalam jendela yang ketat, sehingga hasil basi kedaluwarsa izin. Ini get_account_balance hanya memungkinkan jika transfer_funds selesai dalam lima menit terakhir:

permit (
    principal,
    action == AgentCore::Action::"FundsTarget___get_account_balance",
    resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:us-west-2:123456789012:gateway/my-gateway"
)
when temporal {
    formerly within 5m AgentCore::Action::"FundsTarget___transfer_funds"::response{
        eventResource: resource
    }
};

Pencoco ::response kan bukan ::request merupakan perbedaan dari pengurutan alat: response peristiwa dicatat hanya ketika tindakan berhasil diselesaikan, jadi kebijakan ini memerlukan penyelesaian yang berhasil baru-baru ini, bukan hanya permintaan sebelumnya. Panjang jendela menentukan seberapa baru penyelesaian itu harus; setelah jendela lewat, izin akan berakhir sampai prasyarat berjalan lagi.

Contoh: pembatasan tarif berbasis sesi

Contoh ini membatasi alat pada jumlah panggilan tetap dalam sesi. Kebijakan berikut melarang transfer_funds setelah dipanggil lebih dari tiga kali dalam lima menit dalam sesi:

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

Ek count spresi menghitung transfer_funds permintaan yang direkam dalam sesi dalam lima menit terakhir, termasuk permintaan saat ini; ketika jumlah itu melebihi tiga, larangan berlaku. Pasangkan dengan permit for transfer_funds sehingga panggilan diizinkan hingga batas. Dengan kedua kebijakan tersebut, tiga transfer_funds panggilan pertama dalam jendela lima menit diizinkan, dan panggilan keempat (atau yang lebih baru) di jendela itu ditolak.

Contoh: persetujuan sekali pakai

Contoh ini membuat setiap persetujuan baik untuk satu penggunaan. A transfer_funds diizinkan hanya jika transfer_funds belum selesai sejak yang terbaru get_account_balance (persetujuan) dalam sesi. Setelah transfer selesai, itu menghabiskan persetujuan, dan transfer berikutnya ditolak sampai persetujuan baru terjadi:

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

sinceKondisi ini berlaku ketika penyelesaian get_account_balance (persetujuan) terjadi dalam satu jam terakhir dan tidak ada penyeles transfer_funds aian yang terjadi sejak persetujuan itu. Pencoco ::response kan sangat penting: transfer dihitung sebagai selesai hanya setelah berhasil, sehingga permintaan yang diotorisasi tidak memblokir dirinya sendiri. Pasangkan ini dengan permit untuk get_account_balance sehingga persetujuan dicatat.

Permintaan dalam sesi diputuskan sebagai berikut:

Contoh: anggaran kumulatif

Contoh ini membatasi nilai total tindakan dalam jendela. Kebijakan berikut melarang transfer_funds setelah jumlah amount input di seluruh transfer sesi dalam lima menit terakhir mencapai 3000:

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

Eksp sum resi menambahkan bidang amount input di seluruh transfer_funds permintaan yang cocok di jendela, termasuk permintaan saat ini; ketika total mencapai ambang batas, larangan berlaku. Bidang yang dijumlahkan adalah bidang input dari tindakan. Pasangkan kebijakan dengan permit untuktransfer_funds. Misalnya, dengan ambang 3000 dan transfer 1000, dua yang pertama diizinkan dan yang ketiga, yang akan mencapai 3000, ditolak.

Seperti halnya pembatasan tarif, jumlah dicakup ke sesi saat ini dan tidak digabungkan di seluruh sesi.

Contoh: pendinginan

Contoh ini memberlakukan pendinginan: tindakan tidak dapat diulang dalam periode tetap dari penyelesaian terakhirnya. Ini melarang transfer_funds jika transfer_funds selesai dalam menit terakhir:

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

Kondisi ini bersifat referensial sendiri: cocok dengan tindakan yang sama yang diotorisasi. Pencoco ::response kan adalah apa yang membuatnya berfungsi, karena permintaan yang diotorisasi belum menghasilkan respons, sehingga tidak cocok dengan dirinya sendiri. Pencocokan di ::request sini akan membuat permintaan saat ini cocok dengan acaranya sendiri, dan tindakan akan dilarang secara permanen. Setelah jendela berlalu tanpa penyelesaian baru, tindakan diizinkan lagi.

Contoh: prasyarat berkelanjutan

Contoh ini mengizinkan tindakan hanya saat prasyarat berlaku: konfirmasi positif terjadi baru-baru ini dan tidak ada yang membatalkannya sejak itu. Ini transfer_funds hanya mengizinkan jika get_account_balance (konfirmasi) selesai dalam lima menit terakhir dan tidak ada get_transaction_history (pembatalan) yang telah selesai sejak:

permit (
    principal,
    action == AgentCore::Action::"FundsTarget___transfer_funds",
    resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:us-west-2:123456789012:gateway/my-gateway"
)
when temporal {
    !AgentCore::Action::"FundsTarget___get_transaction_history"::response{ eventResource: resource }
    since within 5m AgentCore::Action::"FundsTarget___get_account_balance"::response{ eventResource: resource }
};

sinceKondisi ini berlaku ketika penyelesaian get_account_balance terjadi dalam lima menit terakhir dan tidak ada penyelesaian yang terjadi get_transaction_history sejak itu. Yang selesai get_account_balance menegaskan prasyarat, dan mengharuskan tidak ada yang terjadi get_transaction_history sejak itu memastikan tidak ada yang membatalkannya sesudahnya. Berikan izin untuk get_transaction_history keduanya get_account_balance dan mereka dicatat.

Contoh: rantai multi-hop

Anda dapat menyusun beberapa kebijakan pengurutan untuk memerlukan rangkaian tindakan, masing-masing diizinkan hanya setelah yang sebelumnya selesai. Contoh ini membutuhkan rantai get_account_balance → get_transaction_history →transfer_funds, menggunakan dua kebijakan (satu per tautan):

// Link 1: permit get_transaction_history only after get_account_balance completed
permit (
    principal,
    action == AgentCore::Action::"FundsTarget___get_transaction_history",
    resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:us-west-2:123456789012:gateway/my-gateway"
)
when temporal {
    formerly within 5m AgentCore::Action::"FundsTarget___get_account_balance"::response{ eventResource: resource }
};

// Link 2: permit transfer_funds only after get_transaction_history completed
permit (
    principal,
    action == AgentCore::Action::"FundsTarget___transfer_funds",
    resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:us-west-2:123456789012:gateway/my-gateway"
)
when temporal {
    formerly within 5m AgentCore::Action::"FundsTarget___get_transaction_history"::response{ eventResource: resource }
};

Setiap kebijakan memberlakukan satu mata rantai, dan rantai muncul dari komposisi mereka: transfer_funds membutuhkanget_transaction_history, yang membutuhkanget_account_balance. Berikan a permit untuk tindakan pertama dalam rantai sehingga dapat dimulai. Langkah yang dicoba rusak ditolak sampai prasyaratnya selesai.

Contoh: pengecualian timbal balik

Contoh ini membuat dua tindakan saling eksklusif dalam jendela: mana yang berjalan lebih dulu memblokir yang lain. Ini menggunakan dua kebijakan larangan simetris sehingga pengecualian berlaku di kedua arah. Di sini, transfer_funds dan get_transaction_history keduanya tidak dapat terjadi dalam dua menit:

// Forbid get_transaction_history if a transfer_funds was requested within 2m
forbid (
    principal,
    action == AgentCore::Action::"FundsTarget___get_transaction_history",
    resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:us-west-2:123456789012:gateway/my-gateway"
)
when temporal {
    formerly within 2m AgentCore::Action::"FundsTarget___transfer_funds"::request{ eventResource: resource }
};

// Forbid transfer_funds if a get_transaction_history was requested within 2m
forbid (
    principal,
    action == AgentCore::Action::"FundsTarget___transfer_funds",
    resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:us-west-2:123456789012:gateway/my-gateway"
)
when temporal {
    formerly within 2m AgentCore::Action::"FundsTarget___get_transaction_history"::request{ eventResource: resource }
};

Karena setiap kebijakan cocok::request, bahkan meminta satu tindakan memblokir yang lain — blok tidak menunggu tindakan pertama selesai. Anda memerlukan dua forbid kebijakan simetris, satu per arah: satu melarang get_transaction_history setelah transfer_funds permintaan, dan yang lainnya melarang transfer_funds setelah permintaan. get_transaction_history Larangan tunggal hanya akan memblokir satu pesanan. Pasangkan keduanya dengan izin untuk dua tindakan.

Contoh: menggabungkan kondisi temporal, pagar pembatas, dan Cedar

Satu kebijakan dapat menggabungkan kondisi temporal dengan pagar pembatas dan kondisi Cedar standar; semuanya harus dipenuhi agar kebijakan dapat diterapkan. Contoh ini transfer_funds hanya mengizinkan jika jumlah transfer kumulatif tetap di bawah batas (temporal), permintaan tidak berisi informasi sensitif (pagar pembatas), dan pemanggil tidak berada dalam grup yang diblokir (Cedar):

permit (
    principal,
    action == AgentCore::Action::"FundsTarget___transfer_funds",
    resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:us-west-2:123456789012:gateway/my-gateway"
)
when temporal {
    exists (total: Long).
        (sum amt for (amt: Long), (t: Timepoint).
            where (formerly within 24h (AgentCore::Action::"FundsTarget___transfer_funds"::request{ eventResource: resource, input.amount: amt } && tp(t)))) == total
        && total < 60000
}
when {
    BedrockGuardrails::SensitiveInformation(["ACCOUNT_NUMBER"], [context.input.body]).count() == 0
}
unless {
    principal in Group::"blocked_users"
};

Blok temporal memberlakukan tutup kumulatif, blok pagar pembatas memblokir permintaan yang berisi informasi sensitif yang terdaftar, dan blok Cedar mengecualikan prinsipal yang unless diblokir. Setiap jenis kondisi dievaluasi secara independen dan izin hanya berlaku jika semuanya berlaku. Untuk sintaks kondisi pagar pembatas, lihat Guardrails dalam kebijakan; blok temporal berperilaku seperti yang dijelaskan dalam contoh sebelumnya.

Contoh: prasyarat paralel

Contoh ini membutuhkan dua prasyarat untuk diselesaikan, dalam urutan apa pun, sebelum tindakan diizinkan. Ini get_account_balance hanya memungkinkan jika keduanya transfer_funds dan get_transaction_history selesai dalam satu jam terakhir, menggabungkan dua formerly kondisi dengan&&:

permit (
    principal,
    action == AgentCore::Action::"FundsTarget___get_account_balance",
    resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:us-west-2:123456789012:gateway/my-gateway"
)
when temporal {
    formerly within 1h AgentCore::Action::"FundsTarget___transfer_funds"::response{ eventResource: resource }
    && formerly within 1h AgentCore::Action::"FundsTarget___get_transaction_history"::response{ eventResource: resource }
};

Kedua prasyarat harus telah menyelesaikan (::response) di dalam jendela, dan urutannya tidak masalah. Berikan izin untuk kedua tindakan prasyarat sehingga dicatat. Menyelesaikan hanya satu membuat tindakan ditolak sampai yang lain juga selesai.

Contoh: ambang persetujuan

Contoh ini mengizinkan tindakan hanya setelah jumlah ambang batas acara yang memenuhi syarat. Ini memungkinkan get_account_balance untuk pelanggan hanya jika setidaknya dua transfer_funds diselesaikan ke akun pelanggan tersebut, menghubungkan transfer toAccount dengan permintaan customerId saldo:

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

Ek count spresi menghitung pencocokan peristiwa yang diselesaikan di jendela, dan tindakan diizinkan setelah hitungan mencapai ambang batas.

Contoh: memblokir tindakan setelah penolakan sebelumnya

Contoh ini memblokir tindakan sensitif ketika panggilan alat sebelumnya di sesi yang sama ditolak. Permintaan yang ditolak dicatat sebagai error peristiwa, dan ::error predikat cocok dengan peristiwa tersebut. Kebijakan berikut melarang transfer_funds setiap kali get_account_balance sesi ditolak dalam tiga menit terakhir:

forbid (
    principal,
    action == AgentCore::Action::"FundsTarget___transfer_funds",
    resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:us-west-2:123456789012:gateway/my-gateway"
)
when temporal {
    formerly within 3m AgentCore::Action::"FundsTarget___get_account_balance"::error{
        eventResource: resource
    }
};

A forbid turan mengesampingkan apa punpermit, jadi pasangkan dengan permit yang memungkinkan dalam transfer_funds kondisi normal:

permit (
    principal,
    action == AgentCore::Action::"FundsTarget___transfer_funds",
    resource == AgentCore::Gateway::"arn:aws:bedrock-agentcore:us-west-2:123456789012:gateway/my-gateway"
);

Dengan kedua kebijakan tersebut, permintaan dalam sesi diputuskan sebagai berikut: