Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Memahami penskalaan fungsi Lambda
**Konkurensi** adalah jumlah permintaan dalam penerbangan yang ditangani oleh AWS Lambda fungsi Anda pada saat yang bersamaan. Untuk setiap permintaan bersamaan, Lambda menyediakan instance terpisah dari lingkungan eksekusi Anda. Saat fungsi Anda menerima lebih banyak permintaan, Lambda secara otomatis menangani penskalaan jumlah lingkungan eksekusi hingga Anda mencapai batas konkurensi akun Anda. Secara default, Lambda menyediakan akun Anda dengan batas konkurensi total 1.000 eksekusi bersamaan di semua fungsi dalam file. Wilayah AWS Untuk mendukung kebutuhan akun spesifik Anda, Anda dapat [meminta peningkatan kuota](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-concurrency-limit-increase/) dan mengonfigurasi kontrol konkurensi tingkat fungsi sehingga fungsi penting Anda tidak mengalami pelambatan.
Topik ini menjelaskan konsep konkurensi dan penskalaan fungsi di Lambda. Pada akhir topik ini, Anda akan dapat memahami cara menghitung konkurensi, memvisualisasikan dua opsi kontrol konkurensi utama (dicadangkan dan disediakan), memperkirakan pengaturan kontrol konkurensi yang sesuai, dan melihat metrik untuk pengoptimalan lebih lanjut.
**Topics**
+ [Memahami dan memvisualisasikan konkurensi](#understanding-concurrency)
+ [Menghitung konkurensi untuk suatu fungsi](#calculating-concurrency)
+ [Memahami konkurensi cadangan dan konkurensi yang disediakan](#reserved-and-provisioned)
+ [Memahami konkurensi dan permintaan per detik](#concurrency-vs-requests-per-second)
+ [Kuota konkurensi](#concurrency-quotas)
+ [Mengkonfigurasi konkurensi cadangan untuk suatu fungsi](configuration-concurrency.md)
+ [Mengkonfigurasi konkurensi yang disediakan untuk suatu fungsi](provisioned-concurrency.md)
+ [Perilaku penskalaan Lambda](scaling-behavior.md)
+ [Memantau konkurensi](monitoring-concurrency.md)
## Memahami dan memvisualisasikan konkurensi
[Lambda memanggil fungsi Anda di lingkungan eksekusi yang aman dan terisolasi.](lambda-runtime-environment.md) [Untuk menangani permintaan, Lambda harus terlebih dahulu menginisialisasi lingkungan eksekusi ([fase Init](lambda-runtime-environment.md#runtimes-lifecycle-ib)), sebelum menggunakannya untuk memanggil fungsi Anda (fase Invoke):](lambda-runtime-environment.md#runtimes-lifecycle-invoke)
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/concurrency-1-environment.png)
**catatan**
Durasi Init dan Invoke yang sebenarnya dapat bervariasi tergantung pada banyak faktor, seperti runtime yang Anda pilih dan kode fungsi Lambda. Diagram sebelumnya tidak dimaksudkan untuk mewakili proporsi yang tepat dari durasi fase Init dan Invoke.
Diagram sebelumnya menggunakan persegi panjang untuk mewakili lingkungan eksekusi tunggal. Ketika fungsi Anda menerima permintaan pertamanya (diwakili oleh lingkaran kuning dengan label`1`), Lambda membuat lingkungan eksekusi baru dan menjalankan kode di luar handler utama Anda selama fase Init. Kemudian, Lambda menjalankan kode handler utama fungsi Anda selama fase Invoke. Selama seluruh proses ini, lingkungan eksekusi ini sibuk dan tidak dapat memproses permintaan lainnya.
Ketika Lambda selesai memproses permintaan pertama, lingkungan eksekusi ini kemudian dapat memproses permintaan tambahan untuk fungsi yang sama. Untuk permintaan berikutnya, Lambda tidak perlu menginisialisasi ulang lingkungan.
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/concurrency-2-two-requests.png)
Pada diagram sebelumnya, Lambda menggunakan kembali lingkungan eksekusi untuk menangani permintaan kedua (diwakili oleh lingkaran kuning dengan label). `2`
Sejauh ini, kami hanya berfokus pada satu contoh lingkungan eksekusi Anda (yaitu, konkurensi 1). Dalam praktiknya, Lambda mungkin perlu menyediakan beberapa instance lingkungan eksekusi secara paralel untuk menangani semua permintaan yang masuk. Ketika fungsi Anda menerima permintaan baru, salah satu dari dua hal dapat terjadi:
+ Jika instance lingkungan eksekusi pra-inisialisasi tersedia, Lambda menggunakannya untuk memproses permintaan.
+ Jika tidak, Lambda membuat instance lingkungan eksekusi baru untuk memproses permintaan.
Misalnya, mari kita jelajahi apa yang terjadi ketika fungsi Anda menerima 10 permintaan:
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/concurrency-3-ten-requests.png)
Dalam diagram sebelumnya, setiap bidang horizontal mewakili contoh lingkungan eksekusi tunggal (diberi label dari `A` melalui`F`). Inilah cara Lambda menangani setiap permintaan:
| Permintaan | Perilaku Lambda | Penalaran |
| --- | --- | --- |
| 1 | Ketentuan lingkungan baru **A** | Ini adalah permintaan pertama; tidak ada instance lingkungan eksekusi yang tersedia. |
| 2 | Ketentuan lingkungan baru **B** | Lingkungan eksekusi yang ada misalnya **A** sibuk. |
| 3 | Ketentuan lingkungan baru **C** | Instans lingkungan eksekusi yang ada **A** dan **B** keduanya sibuk. |
| 4 | Ketentuan lingkungan baru **D** | Instans lingkungan eksekusi yang ada **A**, **B**, dan **C** semuanya sibuk. |
| 5 | Ketentuan lingkungan baru **E** | Contoh lingkungan eksekusi yang ada **A**, **B**, **C**, dan **D** semuanya sibuk. |
| 6 | **Menggunakan kembali lingkungan A** | Lingkungan eksekusi instance **A** telah selesai memproses permintaan **1** dan sekarang tersedia. |
| 7 | **Menggunakan kembali lingkungan B** | Contoh lingkungan eksekusi **B** telah selesai memproses permintaan **2** dan sekarang tersedia. |
| 8 | **Menggunakan kembali lingkungan C** | Contoh lingkungan eksekusi **C** telah selesai memproses permintaan **3** dan sekarang tersedia. |
| 9 | Ketentuan lingkungan baru **F** | Contoh lingkungan eksekusi yang ada **A**, **B**, **C**, **D**, dan **E** semuanya sibuk. |
| 10 | **Menggunakan kembali lingkungan D** | Contoh lingkungan eksekusi **D** telah selesai memproses permintaan **4** dan sekarang tersedia. |
Saat fungsi Anda menerima lebih banyak permintaan bersamaan, Lambda meningkatkan jumlah instance lingkungan eksekusi sebagai respons. Animasi berikut melacak jumlah permintaan bersamaan dari waktu ke waktu:
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/concurrency-4-animation.gif)
Dengan membekukan animasi sebelumnya pada enam titik waktu yang berbeda, kita mendapatkan diagram berikut:
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/concurrency-5-animation-summary.png)
Pada diagram sebelumnya, kita dapat menggambar garis vertikal kapan saja dan menghitung jumlah lingkungan yang memotong garis ini. Ini memberi kita jumlah permintaan bersamaan pada saat itu. Misalnya, pada waktu`t1`, ada tiga lingkungan aktif yang melayani tiga permintaan bersamaan. Jumlah maksimum permintaan bersamaan dalam simulasi ini terjadi pada waktu`t4`, ketika ada enam lingkungan aktif yang melayani enam permintaan bersamaan.
Untuk meringkas, konkurensi fungsi Anda adalah jumlah permintaan bersamaan yang ditangani secara bersamaan. Menanggapi peningkatan konkurensi fungsi Anda, Lambda menyediakan lebih banyak instance lingkungan eksekusi untuk memenuhi permintaan permintaan.
## Menghitung konkurensi untuk suatu fungsi
Secara umum, konkurensi suatu sistem adalah kemampuan untuk memproses lebih dari satu tugas secara bersamaan. Di Lambda, konkurensi adalah jumlah permintaan dalam penerbangan yang ditangani fungsi Anda secara bersamaan. Cara cepat dan praktis untuk mengukur konkurensi fungsi Lambda adalah dengan menggunakan rumus berikut:
```
Concurrency = (average requests per second) * (average request duration in seconds)
```
**Konkurensi berbeda dari permintaan per detik.** Misalnya, fungsi Anda menerima rata-rata 100 permintaan per detik. Jika durasi permintaan rata-rata adalah satu detik, maka memang benar bahwa konkurensi juga 100:
```
Concurrency = (100 requests/second) * (1 second/request) = 100
```
Namun, jika durasi permintaan rata-rata adalah 500 ms, maka konkurensi adalah 50:
```
Concurrency = (100 requests/second) * (0.5 second/request) = 50
```
Apa arti konkurensi 50 dalam praktik? Jika durasi permintaan rata-rata adalah 500 ms, maka Anda dapat menganggap instance fungsi Anda mampu menangani dua permintaan per detik. Kemudian, dibutuhkan 50 instance fungsi Anda untuk menangani beban 100 permintaan per detik. Konkurensi 50 berarti bahwa Lambda harus menyediakan 50 instance lingkungan eksekusi untuk menangani beban kerja ini secara efisien tanpa pembatasan apa pun. Berikut cara mengekspresikan ini dalam bentuk persamaan:
```
Concurrency = (100 requests/second) / (2 requests/second) = 50
```
Jika fungsi Anda menerima dua kali lipat jumlah permintaan (200 permintaan per detik), tetapi hanya membutuhkan separuh waktu untuk memproses setiap permintaan (250 ms), maka konkurensi masih 50:
```
Concurrency = (200 requests/second) * (0.25 second/request) = 50
```
### Uji pemahaman Anda tentang konkurensi
Misalkan Anda memiliki fungsi yang membutuhkan, rata-rata, 200 ms untuk dijalankan. Selama beban puncak, Anda mengamati 5.000 permintaan per detik. Apa konkurensi fungsi Anda selama beban puncak?
#### Jawaban
Durasi fungsi rata-rata adalah 200 ms, atau 0,2 detik. Dengan menggunakan rumus konkurensi, Anda dapat memasukkan angka untuk mendapatkan konkurensi 1.000:
```
Concurrency = (5,000 requests/second) * (0.2 seconds/request) = 1,000
```
Atau, durasi fungsi rata-rata 200 ms berarti bahwa fungsi Anda dapat memproses 5 permintaan per detik. Untuk menangani beban kerja 5.000 permintaan per detik, Anda memerlukan 1.000 instance lingkungan eksekusi. Jadi, konkurensi adalah 1.000:
```
Concurrency = (5,000 requests/second) / (5 requests/second) = 1,000
```
## Memahami konkurensi cadangan dan konkurensi yang disediakan
Secara default, akun Anda memiliki batas konkurensi 1.000 eksekusi bersamaan di semua fungsi di Wilayah. Fungsi Anda berbagi kumpulan 1.000 konkurensi ini berdasarkan permintaan. Fungsi Anda mengalami pelambatan (yaitu, mereka mulai menghapus permintaan) jika Anda kehabisan konkurensi yang tersedia.
Beberapa fungsi Anda mungkin lebih penting daripada yang lain. Akibatnya, Anda mungkin ingin mengonfigurasi pengaturan konkurensi untuk memastikan bahwa fungsi penting mendapatkan konkurensi yang mereka butuhkan. Ada dua jenis kontrol konkurensi yang tersedia: konkurensi cadangan dan konkurensi yang disediakan.
+ Gunakan **konkurensi cadangan** untuk mengatur jumlah maksimum dan minimum instans bersamaan untuk memesan sebagian dari konkurensi akun Anda untuk suatu fungsi. Ini berguna jika Anda tidak ingin fungsi lain mengambil semua konkurensi tanpa syarat yang tersedia. Ketika fungsi sudah memiliki konkurensi terpesan, tidak ada fungsi lain yang dapat menggunakan konkurensi tersebut.
+ Gunakan **konkurensi yang disediakan** untuk menginisialisasi sejumlah instance lingkungan untuk suatu fungsi. Ini berguna untuk mengurangi latensi start dingin.
### Konkurensi terpesan
Jika Anda ingin menjamin bahwa sejumlah konkurensi tersedia untuk fungsi Anda kapan saja, gunakan konkurensi cadangan.
Konkurensi cadangan menetapkan jumlah maksimum dan minimum instance bersamaan yang ingin Anda alokasikan ke fungsi Anda. Saat Anda mendedikasikan konkurensi cadangan ke suatu fungsi, tidak ada fungsi lain yang dapat menggunakan konkurensi itu. Dengan kata lain, pengaturan konkurensi cadangan dapat memengaruhi kumpulan konkurensi yang tersedia untuk fungsi lain. Fungsi yang tidak memiliki konkurensi cadangan berbagi kumpulan konkurensi tanpa syarat yang tersisa.
Mengkonfigurasi jumlah konkurensi cadangan terhadap batas konkurensi akun Anda secara keseluruhan. Tidak ada biaya untuk mengonfigurasi konkurensi terpesan untuk fungsi.
Untuk lebih memahami konkurensi cadangan, pertimbangkan diagram berikut:
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/concurrency-6-reserved-concurrency.png)
Dalam diagram ini, batas konkurensi akun Anda untuk semua fungsi di Wilayah ini berada pada batas default 1.000. Misalkan Anda memiliki dua fungsi penting, `function-blue` dan`function-orange`, yang secara rutin mengharapkan untuk mendapatkan volume pemanggilan yang tinggi. Anda memutuskan untuk memberikan 400 unit konkurensi cadangan ke`function-blue`, dan 400 unit konkurensi cadangan untuk. `function-orange` Dalam contoh ini, semua fungsi lain di akun Anda harus membagikan 200 unit konkurensi tanpa syarat yang tersisa.
Diagram memiliki lima poin menarik:
+ Di`t1`, keduanya `function-orange` dan `function-blue` mulai menerima permintaan. Setiap fungsi mulai menggunakan bagian yang dialokasikan dari unit konkurensi cadangan.
+ Di`t2`, `function-orange` dan `function-blue` terus menerima lebih banyak permintaan. Pada saat yang sama, Anda menerapkan beberapa fungsi Lambda lainnya, yang mulai menerima permintaan. Anda tidak mengalokasikan konkurensi cadangan untuk fungsi-fungsi lain ini. Mereka mulai menggunakan 200 unit konkurensi tanpa syarat yang tersisa.
+ Pada`t3`, `function-orange` mencapai konkurensi maks 400. Meskipun ada konkurensi yang tidak digunakan di tempat lain di akun Anda, `function-orange` tidak dapat mengaksesnya. Garis merah menunjukkan bahwa `function-orange` sedang mengalami pelambatan, dan Lambda dapat membatalkan permintaan.
+ Pada`t4`, `function-orange` mulai menerima lebih sedikit permintaan dan tidak lagi melambat. Namun, fungsi Anda yang lain mengalami lonjakan lalu lintas dan mulai melambat. Meskipun ada konkurensi yang tidak digunakan di tempat lain di akun Anda, fungsi-fungsi lain ini tidak dapat mengaksesnya. Garis merah menunjukkan bahwa fungsi Anda yang lain mengalami pelambatan.
+ Pada`t5`, fungsi lain mulai menerima lebih sedikit permintaan dan tidak lagi melambat.
Dari contoh ini, perhatikan bahwa reserving concurrency memiliki efek sebagai berikut:
+ **Fungsi Anda dapat menskalakan secara independen dari fungsi lain di akun Anda.** Semua fungsi akun Anda di Wilayah yang sama yang tidak memiliki konkurensi cadangan berbagi kumpulan konkurensi tanpa syarat. Tanpa konkurensi cadangan, fungsi lain berpotensi menggunakan semua konkurensi Anda yang tersedia. Ini mencegah fungsi-fungsi penting dari peningkatan skala jika diperlukan.
+ **Fungsi Anda tidak dapat skala di luar kendali.** Konkurensi cadangan membatasi konkurensi maksimum dan minimum fungsi Anda. Ini berarti bahwa fungsi Anda tidak dapat menggunakan konkurensi yang dicadangkan untuk fungsi lain, atau konkurensi dari kumpulan yang tidak dipesan. Selain itu, konkurensi cadangan bertindak sebagai batas bawah dan atas - ia menyimpan kapasitas yang ditentukan secara eksklusif untuk fungsi Anda sementara juga mencegahnya dari penskalaan melampaui batas itu. Anda dapat memesan konkurensi untuk mencegah fungsi Anda menggunakan semua konkurensi yang tersedia di akun Anda, atau membebani sumber daya hilir yang berlebihan.
+ **Anda mungkin tidak dapat menggunakan semua konkurensi akun Anda yang tersedia.** Reservasi konkurensi diperhitungkan terhadap batas konkurensi akun Anda, tetapi ini juga berarti bahwa fungsi lain tidak dapat menggunakan potongan konkurensi cadangan itu. Jika fungsi Anda tidak menggunakan semua konkurensi yang Anda pesan untuk itu, Anda secara efektif membuang-buang konkurensi itu. Ini bukan masalah kecuali fungsi lain di akun Anda bisa mendapatkan keuntungan dari konkurensi yang terbuang.
Untuk mempelajari cara mengelola setelan konkurensi cadangan untuk fungsi Anda, lihat[Mengkonfigurasi konkurensi cadangan untuk suatu fungsi](configuration-concurrency.md).
### Konkurensi yang disediakan
Anda menggunakan konkurensi cadangan untuk menentukan jumlah maksimum lingkungan eksekusi yang dicadangkan untuk fungsi Lambda. Namun, tidak satu pun dari lingkungan ini yang diinisialisasi sebelumnya. Akibatnya, pemanggilan fungsi Anda mungkin memakan waktu lebih lama karena Lambda harus terlebih dahulu menginisialisasi lingkungan baru sebelum dapat menggunakannya untuk memanggil fungsi Anda. [Ketika Lambda harus menginisialisasi lingkungan baru untuk melaksanakan doa, ini dikenal sebagai awal yang dingin.](lambda-runtime-environment.md#cold-start-latency) Untuk mengurangi start dingin, Anda dapat menggunakan konkurensi yang disediakan.
Konkurensi yang disediakan adalah jumlah lingkungan eksekusi pra-inisialisasi yang ingin Anda alokasikan ke fungsi Anda. Jika Anda menyetel konkurensi yang disediakan pada suatu fungsi, Lambda menginisialisasi jumlah lingkungan eksekusi tersebut sehingga mereka siap untuk segera merespons permintaan fungsi.
**catatan**
Menggunakan konkurensi yang disediakan menimbulkan biaya tambahan ke akun Anda. Jika Anda bekerja dengan runtime Java 11 atau Java 17, Anda juga dapat menggunakan SnapStart Lambda untuk mengurangi masalah start dingin tanpa biaya tambahan. SnapStart menggunakan snapshot cache dari lingkungan eksekusi Anda untuk meningkatkan kinerja startup secara signifikan. Anda tidak dapat menggunakan keduanya SnapStart dan konkurensi yang disediakan pada versi fungsi yang sama. Untuk informasi selengkapnya tentang SnapStart fitur, batasan, dan Wilayah yang didukung, lihat[Meningkatkan kinerja startup dengan Lambda SnapStart](snapstart.md).
Saat menggunakan konkurensi yang disediakan, Lambda masih mendaur ulang lingkungan eksekusi di latar belakang. Misalnya, ini dapat terjadi [setelah kegagalan pemanggilan.](lambda-runtime-environment.md#runtimes-lifecycle-invoke-with-errors) Namun, pada waktu tertentu, Lambda selalu memastikan bahwa jumlah lingkungan pra-inisialisasi sama dengan nilai setelan konkurensi yang disediakan fungsi Anda. Yang penting, bahkan jika Anda menggunakan konkurensi yang disediakan, Anda masih dapat mengalami penundaan awal yang dingin jika Lambda harus mengatur ulang lingkungan eksekusi.
Sebaliknya, saat menggunakan konkurensi cadangan, Lambda dapat sepenuhnya mengakhiri lingkungan setelah periode tidak aktif. Diagram berikut mengilustrasikan hal ini dengan membandingkan siklus hidup lingkungan eksekusi tunggal saat Anda mengonfigurasi fungsi menggunakan konkurensi cadangan dibandingkan dengan konkurensi yang disediakan.
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/concurrency-7-reserved-vs-provisioned.png)
Diagram memiliki empat tempat menarik:
| Waktu | Konkurensi terpesan | Konkurensi yang disediakan |
| --- | --- | --- |
| t1 | Tidak ada yang terjadi. | Lambda melakukan pra-inisialisasi instance lingkungan eksekusi. |
| t2 | Permintaan 1 masuk. Lambda harus menginisialisasi instance lingkungan eksekusi baru. | Permintaan 1 masuk. Lambda menggunakan instance lingkungan pra-inisialisasi. |
| t3 | Setelah beberapa tidak aktif, Lambda menghentikan instance lingkungan aktif. | Tidak ada yang terjadi. |
| t4 | Permintaan 2 masuk. Lambda harus menginisialisasi instance lingkungan eksekusi baru. | Permintaan 2 masuk. Lambda menggunakan instance lingkungan pra-inisialisasi. |
Untuk lebih memahami konkurensi yang disediakan, pertimbangkan diagram berikut:
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/concurrency-8-provisioned-concurrency.png)
Dalam diagram ini, Anda memiliki batas konkurensi akun 1.000. Anda memutuskan untuk memberikan 400 unit konkurensi yang disediakan ke. `function-orange` Semua fungsi di akun Anda, *termasuk*`function-orange`, dapat menggunakan sisa 600 unit konkurensi tanpa syarat.
Diagram memiliki lima poin menarik:
+ Pada`t1`, `function-orange` mulai menerima permintaan. Karena Lambda memiliki 400 instance lingkungan eksekusi yang telah diinisialisasi sebelumnya, `function-orange` siap untuk pemanggilan segera.
+ Pada`t2`, `function-orange` mencapai 400 permintaan bersamaan. Akibatnya, `function-orange` kehabisan konkurensi yang disediakan. Namun, karena masih ada konkurensi tanpa syarat yang tersedia, Lambda dapat menggunakan ini untuk menangani permintaan tambahan `function-orange` (tidak ada pembatasan). Lambda harus membuat instance baru untuk melayani permintaan ini, dan fungsi Anda mungkin mengalami latensi start dingin.
+ Pada`t3`, `function-orange` kembali ke 400 permintaan bersamaan setelah lonjakan lalu lintas singkat. Lambda sekali lagi dapat menangani semua permintaan tanpa latensi start dingin.
+ Di`t4`, fungsi di akun Anda mengalami ledakan lalu lintas. Burst ini dapat berasal dari `function-orange` atau fungsi lain di akun Anda. Lambda menggunakan konkurensi tanpa syarat untuk menangani permintaan ini.
+ Di`t5`, fungsi di akun Anda mencapai batas konkurensi maksimum 1.000, dan mengalami pelambatan.
Contoh sebelumnya dianggap hanya konkurensi yang disediakan. Dalam praktiknya, Anda dapat mengatur konkurensi yang disediakan dan konkurensi cadangan pada suatu fungsi. Anda dapat melakukan ini jika Anda memiliki fungsi yang menangani beban pemanggilan yang konsisten pada hari kerja, tetapi secara rutin melihat lonjakan lalu lintas pada akhir pekan. Dalam hal ini, Anda dapat menggunakan konkurensi yang disediakan untuk menetapkan jumlah dasar lingkungan untuk menangani permintaan selama hari kerja, dan menggunakan konkurensi cadangan untuk menangani lonjakan akhir pekan. Pertimbangkan diagram berikut:
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/concurrency-9-reserved-and-provisioned.png)
Dalam diagram ini, misalkan Anda mengonfigurasi 200 unit konkurensi yang disediakan dan 400 unit konkurensi cadangan untuk. `function-orange` Karena Anda mengonfigurasi konkurensi cadangan, `function-orange` tidak dapat menggunakan salah satu dari 600 unit konkurensi tanpa syarat.
Diagram ini memiliki lima poin menarik:
+ Pada`t1`, `function-orange` mulai menerima permintaan. Karena Lambda memiliki 200 instance lingkungan eksekusi yang telah diinisialisasi sebelumnya, `function-orange` siap untuk pemanggilan segera.
+ Di`t2`, `function-orange` menggunakan semua konkurensi yang disediakan. `function-orange`dapat terus melayani permintaan menggunakan konkurensi cadangan, tetapi permintaan ini mungkin mengalami latensi awal yang dingin.
+ Pada`t3`, `function-orange` mencapai 400 permintaan bersamaan. Akibatnya, `function-orange` menggunakan semua konkurensi yang dicadangkan. Karena `function-orange` tidak dapat menggunakan konkurensi tanpa syarat, permintaan mulai melambat.
+ Pada`t4`, `function-orange` mulai menerima lebih sedikit permintaan, dan tidak lagi throttle.
+ Pada`t5`, `function-orange` turun ke 200 permintaan bersamaan, sehingga semua permintaan kembali dapat menggunakan konkurensi yang disediakan (yaitu, tidak ada latensi start dingin).
[Baik konkurensi cadangan maupun konkurensi yang disediakan dihitung terhadap batas konkurensi akun Anda dan kuota Regional.](gettingstarted-limits.md) Dengan kata lain, mengalokasikan konkurensi yang dicadangkan dan disediakan dapat memengaruhi kumpulan konkurensi yang tersedia untuk fungsi lain. Mengkonfigurasi konkurensi yang disediakan menimbulkan biaya ke Anda. Akun AWS
**catatan**
Jika jumlah konkurensi yang disediakan pada versi dan alias fungsi ditambahkan ke konkurensi cadangan fungsi, maka semua pemanggilan berjalan pada konkurensi yang disediakan. Konfigurasi ini juga memiliki efek membatasi versi fungsi yang tidak dipublikasikan (`$LATEST`), yang mencegahnya dijalankan. Anda tidak dapat mengalokasikan lebih banyak konkurensi terprovisi dari konkurensi terpesan untuk fungsi.
Untuk mengelola setelan konkurensi yang disediakan untuk fungsi Anda, lihat. [Mengkonfigurasi konkurensi yang disediakan untuk suatu fungsi](provisioned-concurrency.md) Untuk mengotomatiskan penskalaan konkurensi yang disediakan berdasarkan jadwal atau pemanfaatan aplikasi, lihat. [Menggunakan Application Auto Scaling untuk mengotomatiskan manajemen konkurensi yang disediakan](provisioned-concurrency.md#managing-provisioned-concurency)
### Bagaimana Lambda mengalokasikan konkurensi yang disediakan
Konkurensi yang disediakan tidak langsung online setelah Anda mengonfigurasinya. Lambda mulai mengalokasikan konkurensi terprovisi setelah satu atau dua menit persiapan. Untuk setiap fungsi, Lambda dapat menyediakan hingga 6.000 lingkungan eksekusi setiap menit, terlepas dari itu. Wilayah AWS Ini persis sama dengan [tingkat penskalaan konkurensi untuk fungsi](scaling-behavior.md#scaling-rate).
Saat Anda mengirimkan permintaan untuk mengalokasikan konkurensi yang disediakan, Anda tidak dapat mengakses salah satu lingkungan tersebut hingga Lambda benar-benar selesai mengalokasikannya. Misalnya, jika Anda meminta 5.000 konkurensi yang disediakan, tidak ada permintaan yang dapat menggunakan konkurensi yang disediakan hingga Lambda benar-benar selesai mengalokasikan 5.000 lingkungan eksekusi.
### Membandingkan konkurensi cadangan dan konkurensi yang disediakan
Tabel berikut merangkum dan membandingkan konkurensi yang dicadangkan dan disediakan.
| Topik | Konkurensi terpesan | Konkurensi yang disediakan |
| --- | --- | --- |
| Definisi | Jumlah maksimum instance lingkungan eksekusi untuk fungsi Anda. | Tetapkan jumlah instance lingkungan eksekusi yang telah disediakan sebelumnya untuk fungsi Anda. |
| Perilaku penyediaan | Lambda menyediakan instans baru berdasarkan permintaan. | Instans pra-ketentuan Lambda (yaitu, sebelum fungsi Anda mulai menerima permintaan). |
| Perilaku awal dingin | Latensi start dingin dimungkinkan, karena Lambda harus membuat instance baru sesuai permintaan. | Latensi start dingin tidak dimungkinkan, karena Lambda tidak harus membuat instance sesuai permintaan. |
| Perilaku melambat | Fungsi dibatasi ketika batas konkurensi cadangan tercapai. | Jika konkurensi cadangan tidak disetel: fungsi menggunakan konkurensi tanpa syarat saat batas konkurensi yang disediakan tercapai. Jika set konkurensi cadangan: fungsi dibatasi saat batas konkurensi cadangan tercapai. |
| Perilaku default jika tidak disetel | Fungsi menggunakan konkurensi tanpa syarat yang tersedia di akun Anda. | Lambda tidak menyediakan instans apa pun terlebih dahulu. Sebaliknya, jika konkurensi cadangan tidak disetel: fungsi menggunakan konkurensi tanpa syarat yang tersedia di akun Anda. Jika set konkurensi cadangan: fungsi menggunakan konkurensi cadangan. |
| Harga | Tidak ada biaya tambahan. | Mengalami biaya tambahan. |
## Memahami konkurensi dan permintaan per detik
Seperti disebutkan di bagian sebelumnya, konkurensi berbeda dari permintaan per detik. Ini adalah perbedaan yang sangat penting untuk dibuat ketika bekerja dengan fungsi yang memiliki durasi permintaan rata-rata kurang dari 100 ms.
Di semua fungsi di akun Anda, Lambda memberlakukan batas permintaan per detik yang sama dengan 10 kali konkurensi akun Anda. Misalnya, karena batas konkurensi akun default adalah 1.000, fungsi di akun Anda dapat menangani maksimum 10.000 permintaan per detik.
Misalnya, pertimbangkan fungsi dengan durasi permintaan rata-rata 50 ms. Pada 20.000 permintaan per detik, inilah konkurensi fungsi ini:
```
Concurrency = (20,000 requests/second) * (0.05 second/request) = 1,000
```
Berdasarkan hasil ini, Anda mungkin berharap bahwa batas konkurensi akun 1.000 cukup untuk menangani beban ini. Namun, karena batas 10.000 permintaan per detik, fungsi Anda hanya dapat menangani 10.000 permintaan per detik dari total 20.000 permintaan. Fungsi ini mengalami pelambatan.
Pelajarannya adalah Anda harus mempertimbangkan konkurensi dan permintaan per detik saat mengonfigurasi pengaturan konkurensi untuk fungsi Anda. Dalam hal ini, Anda perlu meminta peningkatan batas konkurensi akun menjadi 2.000, karena ini akan meningkatkan total permintaan per batas detik Anda menjadi 20.000.
**catatan**
Berdasarkan batas permintaan per detik ini, tidak benar untuk mengatakan bahwa setiap lingkungan eksekusi Lambda hanya dapat menangani maksimum 10 permintaan per detik. Alih-alih mengamati beban pada setiap lingkungan eksekusi individu, Lambda hanya mempertimbangkan keseluruhan konkurensi dan permintaan keseluruhan per detik saat menghitung kuota Anda.
### Uji pemahaman Anda tentang konkurensi (fungsi sub-100 ms)
Misalkan Anda memiliki fungsi yang membutuhkan, rata-rata, 20 ms untuk dijalankan. Selama beban puncak, Anda mengamati 30.000 permintaan per detik. Apa konkurensi fungsi Anda selama beban puncak?
#### Jawaban
Durasi fungsi rata-rata adalah 20 ms, atau 0,02 detik. Dengan menggunakan rumus konkurensi, Anda dapat memasukkan angka untuk mendapatkan konkurensi 600:
```
Concurrency = (30,000 requests/second) * (0.02 seconds/request) = 600
```
Secara default, batas konkurensi akun 1.000 tampaknya cukup untuk menangani beban ini. Namun, batas permintaan per detik 10.000 tidak cukup untuk menangani 30.000 permintaan per detik yang masuk. Untuk sepenuhnya mengakomodasi 30.000 permintaan, Anda perlu meminta peningkatan batas konkurensi akun menjadi 3.000 atau lebih tinggi.
Batas permintaan per detik berlaku untuk semua kuota di Lambda yang melibatkan konkurensi. [Dengan kata lain, ini berlaku untuk fungsi on-demand sinkron, fungsi yang menggunakan konkurensi yang disediakan, dan perilaku penskalaan konkurensi.](scaling-behavior.md) Misalnya, berikut adalah beberapa skenario di mana Anda harus mempertimbangkan dengan cermat batas konkurensi dan permintaan per detik Anda:
+ Fungsi yang menggunakan konkurensi sesuai permintaan dapat mengalami peningkatan ledakan 500 konkurensi setiap 10 detik, atau 5.000 permintaan per detik setiap 10 detik, mana yang terjadi lebih dulu.
+ Misalkan Anda memiliki fungsi yang memiliki alokasi konkurensi yang disediakan 10. Fungsi ini tumpah ke konkurensi sesuai permintaan setelah 10 konkurensi atau 100 permintaan per detik, mana yang terjadi lebih dulu.
## Kuota konkurensi
Lambda menetapkan kuota untuk jumlah total konkurensi yang dapat Anda gunakan di semua fungsi di Wilayah. Kuota ini ada pada dua tingkatan:
+ **Pada tingkat akun**, fungsi Anda dapat memiliki hingga 1.000 unit konkurensi secara default. Untuk meningkatkan batas ini, lihat [Meminta peningkatan kuota pada Panduan](https://docs.aws.amazon.com/servicequotas/latest/userguide/request-quota-increase.html) Pengguna *Service Quotas*.
+ **Pada tingkat fungsi**, Anda dapat memesan hingga 900 unit konkurensi di semua fungsi Anda secara default. Terlepas dari total batas konkurensi akun Anda, Lambda selalu mencadangkan 100 unit konkurensi untuk fungsi Anda yang tidak secara eksplisit mencadangkan konkurensi. Misalnya, jika Anda meningkatkan batas konkurensi akun Anda menjadi 2.000, maka Anda dapat memesan hingga 1.900 unit konkurensi di tingkat fungsi.
+ Pada tingkat akun dan tingkat fungsi, Lambda juga memberlakukan batas permintaan per detik sebesar 10 kali kuota konkurensi yang sesuai. [Misalnya, ini berlaku untuk konkurensi tingkat akun, fungsi yang menggunakan konkurensi sesuai permintaan, fungsi yang menggunakan konkurensi yang ditentukan, dan perilaku penskalaan konkurensi.](scaling-behavior.md) Untuk informasi selengkapnya, lihat [Memahami konkurensi dan permintaan per detik](#concurrency-vs-requests-per-second).
Untuk memeriksa kuota konkurensi tingkat akun Anda saat ini, gunakan AWS Command Line Interface (AWS CLI) untuk menjalankan perintah berikut:
```
aws lambda get-account-settings
```
Anda akan melihat output yang terlihat seperti berikut:
```
{
"AccountLimit": {
"TotalCodeSize": 80530636800,
"CodeSizeUnzipped": 262144000,
"CodeSizeZipped": 52428800,
"ConcurrentExecutions": 1000,
"UnreservedConcurrentExecutions": 900
},
"AccountUsage": {
"TotalCodeSize": 410759889,
"FunctionCount": 8
}
}
```
`ConcurrentExecutions`adalah total kuota konkurensi tingkat akun Anda. `UnreservedConcurrentExecutions`adalah jumlah konkurensi cadangan yang masih dapat Anda alokasikan ke fungsi Anda.
Saat fungsi Anda menerima lebih banyak permintaan, Lambda secara otomatis meningkatkan jumlah lingkungan eksekusi untuk menangani permintaan ini hingga akun Anda mencapai kuota konkurensinya. Namun, untuk melindungi dari penskalaan berlebih sebagai respons terhadap ledakan lalu lintas yang tiba-tiba, Lambda membatasi seberapa cepat fungsi Anda dapat menskalakan. Tingkat **penskalaan konkurensi ini adalah tingkat** maksimum di mana fungsi di akun Anda dapat menskalakan sebagai respons terhadap peningkatan permintaan. (Artinya, seberapa cepat Lambda dapat membuat lingkungan eksekusi baru.) Tingkat penskalaan konkurensi berbeda dari batas konkurensi tingkat akun, yang merupakan jumlah total konkurensi yang tersedia untuk fungsi Anda.
**Di masing-masing Wilayah AWS, dan untuk setiap fungsi, tingkat penskalaan konkurensi Anda adalah 1.000 instance lingkungan eksekusi setiap 10 detik (atau 10.000 permintaan per detik setiap 10 detik).** Dengan kata lain, setiap 10 detik, Lambda dapat mengalokasikan paling banyak 1.000 instance lingkungan eksekusi tambahan, atau mengakomodasi 10.000 permintaan tambahan per detik, ke setiap fungsi Anda.
Biasanya, Anda tidak perlu khawatir tentang batasan ini. Tingkat penskalaan Lambda cukup untuk sebagian besar kasus penggunaan.
Yang penting, tingkat penskalaan konkurensi adalah batas tingkat fungsi. Ini berarti bahwa setiap fungsi di akun Anda dapat menskalakan secara independen dari fungsi lainnya.
Untuk informasi selengkapnya tentang perilaku penskalaan, lihat[Perilaku penskalaan Lambda](scaling-behavior.md).
# Mengkonfigurasi konkurensi cadangan untuk suatu fungsi
Di Lambda, [konkurensi](lambda-concurrency.md) adalah jumlah permintaan dalam penerbangan yang saat ini ditangani oleh fungsi Anda. Ada dua tipe kontrol konkurensi yang tersedia:
+ Konkurensi cadangan - Ini menetapkan jumlah maksimum dan minimum instance bersamaan yang dialokasikan ke fungsi Anda. Ketika fungsi sudah memiliki konkurensi terpesan, tidak ada fungsi lain yang dapat menggunakan konkurensi tersebut. Konkurensi cadangan berguna untuk memastikan bahwa fungsi Anda yang paling penting selalu memiliki konkurensi yang cukup untuk menangani permintaan yang masuk. Selain itu, konkurensi cadangan dapat digunakan untuk membatasi konkurensi untuk mencegah sumber daya hilir yang berlebihan, seperti koneksi basis data. Konkurensi cadangan bertindak sebagai batas bawah dan atas - ia menyimpan kapasitas yang ditentukan secara eksklusif untuk fungsi Anda sementara juga mencegahnya dari penskalaan melampaui batas itu. Mengkonfigurasi konkurensi cadangan untuk suatu fungsi tidak menimbulkan biaya tambahan.
+ Konkurensi yang disediakan — Ini adalah jumlah lingkungan eksekusi pra-inisialisasi yang dialokasikan untuk fungsi Anda. Lingkungan eksekusi ini siap merespons segera permintaan fungsi yang masuk. Konkurensi yang disediakan berguna untuk mengurangi latensi start dingin untuk fungsi dan dirancang untuk membuat fungsi tersedia dengan waktu respons milidetik dua digit. Umumnya, beban kerja interaktif paling diuntungkan dari fitur ini. Itu adalah aplikasi dengan pengguna yang memulai permintaan, seperti aplikasi web dan seluler, dan paling sensitif terhadap latensi. Beban kerja asinkron, seperti pipa pemrosesan data, seringkali kurang sensitif terhadap latensi sehingga biasanya tidak memerlukan konkurensi yang disediakan. Mengkonfigurasi konkurensi yang disediakan menimbulkan biaya tambahan untuk Anda. Akun AWS
Topik ini merinci cara mengelola dan mengonfigurasi konkurensi cadangan. Untuk gambaran konseptual dari dua jenis kontrol konkurensi ini, lihat Konkurensi cadangan [dan konkurensi yang disediakan](https://docs.aws.amazon.com/lambda/latest/dg/lambda-concurrency.html#reserved-and-provisioned). Untuk informasi tentang mengonfigurasi konkurensi yang disediakan, lihat. [Mengkonfigurasi konkurensi yang disediakan untuk suatu fungsi](provisioned-concurrency.md)
**catatan**
Fungsi Lambda yang ditautkan ke pemetaan sumber peristiwa Amazon MQ memiliki konkurensi maksimum default. Untuk Apache Active MQ, jumlah maksimum instans bersamaan adalah 5. Untuk Rabbit MQ, jumlah maksimum instans bersamaan adalah 1. Menyetel konkurensi cadangan atau yang disediakan untuk fungsi Anda tidak mengubah batasan ini. Untuk meminta peningkatan konkurensi maksimum default saat menggunakan Amazon MQ, hubungi. Dukungan
**Topics**
+ [Mengonfigurasi konkurensi terpesan](#configuring-concurrency-reserved)
+ [Memperkirakan secara akurat konkurensi cadangan yang diperlukan untuk suatu fungsi](#estimating-reserved-concurrency)
## Mengonfigurasi konkurensi terpesan
Anda dapat mengonfigurasi setelan konkurensi cadangan untuk suatu fungsi menggunakan konsol Lambda atau API Lambda.
**Untuk mencadangkan konkurensi untuk fungsi (konsol)**
1. Buka [halaman Fungsi](https://console.aws.amazon.com/lambda/home#/functions) di konsol Lambda.
1. Pilih fungsi yang ingin Anda pesan konkurensi.
1. Pilih **Konfigurasi**, lalu pilih **Konkurensi**.
1. Dalam **Konkurensi**, pilih **Edit**.
1. Pilih **Pesan konkurensi**. Masukkan jumlah konkurensi yang dipesan untuk fungsi tersebut.
1. Pilih **Simpan**.
Anda dapat melakukan reservasi hingga nilai **konkurensi akun Unreserved** dikurangi 100. 100 unit konkurensi yang tersisa adalah untuk fungsi yang tidak menggunakan konkurensi cadangan. Misalnya, jika akun Anda memiliki batas konkurensi 1.000, Anda tidak dapat memesan semua 1.000 unit konkurensi ke satu fungsi.
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/concurrency-reserve-over-limit.png)
Pemesanan konkurensi untuk suatu fungsi memengaruhi kumpulan konkurensi yang tersedia untuk fungsi lain. Misalnya, jika Anda memesan 100 unit konkurensi untuk`function-a`, fungsi lain di akun Anda harus berbagi 900 unit konkurensi yang tersisa, bahkan jika `function-a` tidak menggunakan semua 100 unit konkurensi cadangan.
Untuk sengaja membatasi fungsi, atur konkurensi cadangannya ke 0. Ini menghentikan fungsi Anda dari memproses peristiwa apa pun hingga Anda menghapus batasnya.
Untuk mengonfigurasi konkurensi cadangan dengan Lambda API, gunakan operasi API berikut.
+ [PutFunctionConcurrency](https://docs.aws.amazon.com/lambda/latest/api/API_PutFunctionConcurrency.html)
+ [GetFunctionConcurrency](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunctionConcurrency.html)
+ [DeleteFunctionConcurrency](https://docs.aws.amazon.com/lambda/latest/api/API_DeleteFunctionConcurrency.html)
Misalnya, untuk mengonfigurasi konkurensi cadangan dengan AWS Command Line Interface (CLI), gunakan `put-function-concurrency` perintah. Perintah berikut menyimpan 100 unit konkurensi untuk fungsi bernama`my-function`:
```
aws lambda put-function-concurrency --function-name my-function \
--reserved-concurrent-executions 100
```
Anda akan melihat output yang terlihat seperti berikut:
```
{
"ReservedConcurrentExecutions": 100
}
```
## Memperkirakan secara akurat konkurensi cadangan yang diperlukan untuk suatu fungsi
[Jika fungsi Anda saat ini melayani lalu lintas, Anda dapat dengan mudah melihat metrik konkurensi menggunakan CloudWatch metrik.](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/working_with_metrics.html) Secara khusus, `ConcurrentExecutions` metrik menunjukkan jumlah pemanggilan bersamaan untuk setiap fungsi di akun Anda.
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/concurrency-concurrent-executions-metrics.png)
Grafik sebelumnya menunjukkan bahwa fungsi ini melayani rata-rata 5 hingga 10 permintaan bersamaan pada waktu tertentu, dan memuncak pada 20 permintaan pada hari biasa. Misalkan ada banyak fungsi lain di akun Anda. ** Jika fungsi ini sangat penting untuk aplikasi Anda dan Anda tidak ingin membatalkan permintaan apa pun**, gunakan angka yang lebih besar dari atau sama dengan 20 sebagai pengaturan konkurensi cadangan Anda.
Atau, ingatlah bahwa Anda juga dapat [menghitung konkurensi](https://docs.aws.amazon.com/lambda/latest/dg/lambda-concurrency.html#calculating-concurrency) menggunakan rumus berikut:
```
Concurrency = (average requests per second) * (average request duration in seconds)
```
Mengalikan permintaan rata-rata per detik dengan durasi permintaan rata-rata dalam hitungan detik memberi Anda perkiraan kasar tentang berapa banyak konkurensi yang perlu Anda pesan. Anda dapat memperkirakan permintaan rata-rata per detik menggunakan `Invocation` metrik, dan durasi permintaan rata-rata dalam detik menggunakan `Duration` metrik. Lihat [Menggunakan CloudWatch metrik dengan Lambda](monitoring-metrics.md) untuk detail selengkapnya.
Anda juga harus terbiasa dengan kendala throughput hulu dan hilir Anda. Sementara fungsi Lambda berskala mulus dengan beban, dependensi hulu dan hilir mungkin tidak memiliki kemampuan throughput yang sama. Jika Anda perlu membatasi seberapa tinggi skala fungsi Anda, konfigurasikan konkurensi cadangan pada fungsi Anda.
# Mengkonfigurasi konkurensi yang disediakan untuk suatu fungsi
Di Lambda, [konkurensi](lambda-concurrency.md) adalah jumlah permintaan dalam penerbangan yang saat ini ditangani oleh fungsi Anda. Ada dua tipe kontrol konkurensi yang tersedia:
+ Konkurensi cadangan - Ini menetapkan jumlah maksimum dan minimum instance bersamaan yang dialokasikan ke fungsi Anda. Ketika fungsi sudah memiliki konkurensi terpesan, tidak ada fungsi lain yang dapat menggunakan konkurensi tersebut. Konkurensi cadangan berguna untuk memastikan bahwa fungsi Anda yang paling penting selalu memiliki konkurensi yang cukup untuk menangani permintaan yang masuk. Selain itu, konkurensi cadangan dapat digunakan untuk membatasi konkurensi untuk mencegah sumber daya hilir yang berlebihan, seperti koneksi basis data. Konkurensi cadangan bertindak sebagai batas bawah dan atas - ia menyimpan kapasitas yang ditentukan secara eksklusif untuk fungsi Anda sementara juga mencegahnya dari penskalaan melampaui batas itu. Mengkonfigurasi konkurensi cadangan untuk suatu fungsi tidak menimbulkan biaya tambahan.
+ Konkurensi yang disediakan — Ini adalah jumlah lingkungan eksekusi pra-inisialisasi yang dialokasikan untuk fungsi Anda. Lingkungan eksekusi ini siap merespons segera permintaan fungsi yang masuk. Konkurensi yang disediakan berguna untuk mengurangi latensi start dingin untuk fungsi dan dirancang untuk membuat fungsi tersedia dengan waktu respons milidetik dua digit. Umumnya, beban kerja interaktif paling diuntungkan dari fitur ini. Itu adalah aplikasi dengan pengguna yang memulai permintaan, seperti aplikasi web dan seluler, dan paling sensitif terhadap latensi. Beban kerja asinkron, seperti pipa pemrosesan data, seringkali kurang sensitif terhadap latensi sehingga biasanya tidak memerlukan konkurensi yang disediakan. Mengkonfigurasi konkurensi yang disediakan menimbulkan biaya tambahan untuk Anda. Akun AWS
Topik ini merinci cara mengelola dan mengonfigurasi konkurensi yang disediakan. Untuk gambaran konseptual dari dua jenis kontrol konkurensi ini, lihat Konkurensi cadangan [dan konkurensi yang disediakan](https://docs.aws.amazon.com/lambda/latest/dg/lambda-concurrency.html#reserved-and-provisioned). Untuk informasi selengkapnya tentang mengonfigurasi konkurensi cadangan, lihat. [Mengkonfigurasi konkurensi cadangan untuk suatu fungsi](configuration-concurrency.md)
**catatan**
Fungsi Lambda yang ditautkan ke pemetaan sumber peristiwa Amazon MQ memiliki konkurensi maksimum default. Untuk Apache Active MQ, jumlah maksimum instans bersamaan adalah 5. Untuk Rabbit MQ, jumlah maksimum instans bersamaan adalah 1. Menyetel konkurensi cadangan atau yang disediakan untuk fungsi Anda tidak mengubah batasan ini. Untuk meminta peningkatan konkurensi maksimum default saat menggunakan Amazon MQ, hubungi. Dukungan
**Topics**
+ [Mengonfigurasi konkurensi yang tersedia](#configuring-provisioned-concurrency)
+ [Memperkirakan konkurensi yang disediakan secara akurat untuk suatu fungsi](#estimating-provisioned-concurrency)
+ [Mengoptimalkan kode fungsi saat menggunakan konkurensi yang disediakan](#optimizing-latency)
+ [Menggunakan variabel lingkungan untuk melihat dan mengontrol perilaku konkurensi yang disediakan](#pc-environment-variables)
+ [Memahami perilaku pencatatan dan penagihan dengan konkurensi yang disediakan](#pc-logging-behavior)
+ [Menggunakan Application Auto Scaling untuk mengotomatiskan manajemen konkurensi yang disediakan](#managing-provisioned-concurency)
## Mengonfigurasi konkurensi yang tersedia
Anda dapat mengonfigurasi setelan konkurensi yang disediakan untuk suatu fungsi menggunakan konsol Lambda atau API Lambda.
**Untuk mengalokasikan konkurensi yang disediakan untuk fungsi (konsol)**
1. Buka [halaman Fungsi](https://console.aws.amazon.com/lambda/home#/functions) di konsol Lambda.
1. Pilih fungsi yang ingin Anda alokasikan konkurensi yang disediakan.
1. Pilih **Konfigurasi**, lalu pilih **Konkurensi**.
1. Dalam **Konfigurasi konkurensi terprovisi**, pilih **Tambah konfigurasi**.
1. Pilih jenis qualifier, dan alias atau versi.
**catatan**
Anda tidak dapat menggunakan konkurensi yang disediakan dengan versi \$1LATEST dari fungsi apa pun.
Jika fungsi Anda memiliki sumber peristiwa, pastikan bahwa sumber peristiwa menunjuk ke alias atau versi fungsi yang benar. Jika tidak, fungsi Anda tidak akan menggunakan lingkungan konkurensi yang disediakan.
1. Masukkan nomor di bawah **Konkurensi yang disediakan.**
1. Pilih **Simpan**.
Anda dapat mengonfigurasi hingga **konkurensi akun Unreserved** di akun Anda, minus 100. 100 unit konkurensi yang tersisa adalah untuk fungsi yang tidak menggunakan konkurensi cadangan. Misalnya, jika akun Anda memiliki batas konkurensi 1.000, dan Anda belum menetapkan konkurensi cadangan atau ketentuan apa pun ke fungsi lainnya, Anda dapat mengonfigurasi maksimum 900 unit konkurensi yang disediakan untuk satu fungsi.
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/provisioned-concurrency-over-limit.png)
Mengkonfigurasi konkurensi yang disediakan untuk suatu fungsi berdampak pada kumpulan konkurensi yang tersedia untuk fungsi lain. Misalnya, jika Anda mengonfigurasi 100 unit konkurensi yang disediakan untuk`function-a`, fungsi lain di akun Anda harus berbagi 900 unit konkurensi yang tersisa. Ini benar bahkan jika `function-a` tidak menggunakan semua 100 unit.
Dimungkinkan untuk mengalokasikan konkurensi cadangan dan konkurensi yang disediakan untuk fungsi yang sama. Dalam kasus seperti itu, konkurensi yang disediakan tidak dapat melebihi konkurensi yang dicadangkan.
Batasan ini meluas ke versi fungsi. Konkurensi maksimum yang disediakan yang dapat Anda tetapkan ke versi fungsi tertentu adalah konkurensi cadangan fungsi dikurangi konkurensi yang disediakan pada versi fungsi lainnya.
Untuk mengonfigurasi konkurensi yang disediakan dengan API Lambda, gunakan operasi API berikut.
+ [PutProvisionedConcurrencyConfig](https://docs.aws.amazon.com/lambda/latest/api/API_PutProvisionedConcurrencyConfig.html)
+ [GetProvisionedConcurrencyConfig](https://docs.aws.amazon.com/lambda/latest/api/API_GetProvisionedConcurrencyConfig.html)
+ [ListProvisionedConcurrencyConfigs](https://docs.aws.amazon.com/lambda/latest/api/API_ListProvisionedConcurrencyConfigs.html)
+ [DeleteProvisionedConcurrencyConfig](https://docs.aws.amazon.com/lambda/latest/api/API_DeleteProvisionedConcurrencyConfig.html)
Misalnya, untuk mengkonfigurasi konkurensi yang disediakan dengan ( AWS Command Line Interface CLI), gunakan perintah. `put-provisioned-concurrency-config` Perintah berikut mengalokasikan 100 unit konkurensi yang disediakan untuk `BLUE` alias fungsi bernama: `my-function`
```
aws lambda put-provisioned-concurrency-config --function-name my-function \
--qualifier BLUE \
--provisioned-concurrent-executions 100
```
Anda akan melihat output yang terlihat seperti berikut:
```
{
"Requested ProvisionedConcurrentExecutions": 100,
"Allocated ProvisionedConcurrentExecutions": 0,
"Status": "IN_PROGRESS",
"LastModified": "2023-01-21T11:30:00+0000"
}
```
## Memperkirakan konkurensi yang disediakan secara akurat untuk suatu fungsi
[Anda dapat melihat metrik konkurensi fungsi aktif apa pun menggunakan CloudWatch metrik.](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/working_with_metrics.html) Secara khusus, `ConcurrentExecutions` metrik menunjukkan jumlah pemanggilan bersamaan untuk fungsi di akun Anda.
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/concurrency-concurrent-executions-metrics.png)
Grafik sebelumnya menunjukkan bahwa fungsi ini melayani rata-rata 5 hingga 10 permintaan bersamaan pada waktu tertentu, dan memuncak pada 20 permintaan. Misalkan ada banyak fungsi lain di akun Anda. ** Jika fungsi ini sangat penting untuk aplikasi Anda dan Anda memerlukan respons latensi rendah pada setiap pemanggilan**, konfigurasikan setidaknya 20 unit konkurensi yang disediakan.
Ingatlah bahwa Anda juga dapat [menghitung konkurensi](https://docs.aws.amazon.com/lambda/latest/dg/lambda-concurrency.html#calculating-concurrency) menggunakan rumus berikut:
```
Concurrency = (average requests per second) * (average request duration in seconds)
```
Untuk memperkirakan berapa banyak konkurensi yang Anda butuhkan, kalikan permintaan rata-rata per detik dengan durasi permintaan rata-rata dalam hitungan detik. Anda dapat memperkirakan permintaan rata-rata per detik menggunakan `Invocation` metrik, dan durasi permintaan rata-rata dalam detik menggunakan `Duration` metrik.
Saat mengonfigurasi konkurensi yang disediakan, Lambda menyarankan untuk menambahkan buffer 10% di atas jumlah konkurensi yang biasanya dibutuhkan fungsi Anda. Misalnya, jika fungsi Anda biasanya memuncak pada 200 permintaan bersamaan, setel konkurensi yang disediakan ke 220 (200 permintaan bersamaan \$1 10% = 220 konkurensi yang disediakan).
## Mengoptimalkan kode fungsi saat menggunakan konkurensi yang disediakan
Jika Anda menggunakan konkurensi yang disediakan, pertimbangkan untuk merestrukturisasi kode fungsi Anda untuk mengoptimalkan latensi rendah. Untuk fungsi yang menggunakan konkurensi yang disediakan, Lambda menjalankan kode inisialisasi apa pun, seperti memuat pustaka dan membuat instance klien, selama waktu alokasi. Oleh karena itu, disarankan untuk memindahkan sebanyak mungkin inisialisasi di luar penangan fungsi utama untuk menghindari dampak latensi selama pemanggilan fungsi aktual. Sebaliknya, menginisialisasi pustaka atau membuat instance klien dalam kode pengendali utama Anda berarti fungsi Anda harus menjalankan ini setiap kali dipanggil (ini terjadi terlepas dari apakah Anda menggunakan konkurensi yang disediakan).
Untuk pemanggilan sesuai permintaan, Lambda mungkin perlu menjalankan ulang kode inisialisasi Anda setiap kali fungsi Anda mengalami awal yang dingin. Untuk fungsi tersebut, Anda dapat memilih untuk menunda inisialisasi kemampuan tertentu sampai fungsi Anda membutuhkannya. Misalnya, pertimbangkan alur kontrol berikut untuk handler Lambda:
```
def handler(event, context):
...
if ( some_condition ):
// Initialize CLIENT_A to perform a task
else:
// Do nothing
```
Pada contoh sebelumnya, alih-alih menginisialisasi `CLIENT_A` di luar handler utama, pengembang menginisialisasinya dalam pernyataan. `if` Dengan melakukan ini, Lambda menjalankan kode ini hanya jika `some_condition` terpenuhi. Jika Anda menginisialisasi `CLIENT_A` di luar penangan utama, Lambda menjalankan kode itu di setiap awal yang dingin. Ini dapat meningkatkan latensi keseluruhan.
Anda dapat mengukur awal dingin saat Lambda meningkat dengan menambahkan pemantauan X-Ray ke fungsi Anda. Fungsi yang menggunakan konkurensi yang disediakan tidak menunjukkan perilaku start dingin karena lingkungan eksekusi disiapkan sebelum pemanggilan. Namun, konkurensi yang disediakan harus diterapkan ke [versi atau alias fungsi tertentu, bukan versi](https://docs.aws.amazon.com/lambda/latest/dg/configuration-versions.html) \$1LATEST. Dalam kasus di mana Anda terus melihat perilaku start dingin, pastikan Anda menjalankan versi alias dengan konkurensi yang disediakan yang dikonfigurasi.
## Menggunakan variabel lingkungan untuk melihat dan mengontrol perilaku konkurensi yang disediakan
Dimungkinkan bagi fungsi Anda untuk menggunakan semua konkurensi yang disediakan. Lambda menggunakan instans sesuai permintaan untuk menangani kelebihan lalu lintas. Untuk menentukan jenis inisialisasi Lambda yang digunakan untuk lingkungan tertentu, periksa nilai variabel lingkungan. `AWS_LAMBDA_INITIALIZATION_TYPE` Variabel ini memiliki dua nilai yang mungkin: `provisioned-concurrency` atau`on-demand`. Nilai `AWS_LAMBDA_INITIALIZATION_TYPE` tidak dapat diubah dan tetap konstan sepanjang masa hidup lingkungan. Untuk memeriksa nilai variabel lingkungan dalam kode fungsi Anda, lihat[Mengambil variabel lingkungan Lambda](configuration-envvars.md#retrieve-environment-variables).
Jika Anda menggunakan runtime .NET 8, Anda dapat mengonfigurasi variabel `AWS_LAMBDA_DOTNET_PREJIT` lingkungan untuk meningkatkan latensi fungsi, bahkan jika mereka tidak menggunakan konkurensi yang disediakan. Runtime.NET menggunakan kompilasi dan inisialisasi malas untuk setiap pustaka yang dipanggil kode Anda untuk pertama kalinya. Akibatnya, pemanggilan pertama fungsi Lambda mungkin memakan waktu lebih lama dari yang berikutnya. Untuk mengurangi ini, Anda dapat memilih salah satu dari tiga nilai untuk: `AWS_LAMBDA_DOTNET_PREJIT`
+ `ProvisionedConcurrency`: Lambda melakukan kompilasi ahead-of-time JIT untuk semua lingkungan menggunakan konkurensi yang disediakan. Ini adalah nilai default.
+ `Always`: Lambda melakukan kompilasi ahead-of-time JIT untuk setiap lingkungan, bahkan jika fungsinya tidak menggunakan konkurensi yang disediakan.
+ `Never`: Lambda menonaktifkan kompilasi ahead-of-time JIT untuk semua lingkungan.
## Memahami perilaku pencatatan dan penagihan dengan konkurensi yang disediakan
Untuk lingkungan konkurensi yang disediakan, kode inisialisasi fungsi Anda berjalan selama alokasi, dan secara berkala saat Lambda mendaur ulang instance lingkungan Anda. Lambda menagih Anda untuk inisialisasi meskipun instance lingkungan tidak pernah memproses permintaan. Konkurensi yang disediakan berjalan terus menerus dan menimbulkan penagihan terpisah dari biaya inisialisasi dan pemanggilan. Untuk detail selengkapnya, lihat [AWS Lambda Harga](https://aws.amazon.com/lambda/pricing/).
Saat Anda mengonfigurasi fungsi Lambda dengan konkurensi yang disediakan, Lambda melakukan pra-inisialisasi lingkungan eksekusi tersebut sehingga tersedia sebelum permintaan pemanggilan. Lambda mencatat [bidang Init Duration](lambda-runtime-environment.md#runtimes-lifecycle-ib) dari fungsi dalam peristiwa log [Platform-initReport](telemetry-schema-reference.md#platform-initReport) dalam format logging JSON setiap kali lingkungan diinisialisasi. Untuk melihat peristiwa log ini, konfigurasikan [level log JSON](monitoring-cloudwatchlogs-logformat.md) Anda ke setidaknya`INFO`. Anda juga dapat menggunakan [API Telemetri](telemetry-api-reference.md) untuk menggunakan peristiwa platform tempat bidang Durasi Init dilaporkan.
## Menggunakan Application Auto Scaling untuk mengotomatiskan manajemen konkurensi yang disediakan
Anda dapat menggunakan Application Auto Scaling untuk mengelola konkurensi yang disediakan sesuai jadwal atau berdasarkan pemanfaatan. Jika fungsi Anda menerima pola lalu lintas yang dapat diprediksi, gunakan penskalaan terjadwal. Jika Anda ingin fungsi Anda mempertahankan persentase pemanfaatan tertentu, gunakan kebijakan penskalaan pelacakan target.
**catatan**
Jika Anda menggunakan Application Auto Scaling untuk mengelola konkurensi yang disediakan fungsi Anda, pastikan Anda [mengonfigurasi nilai konkurensi awal yang](#configuring-provisioned-concurrency) disediakan terlebih dahulu. Jika fungsi Anda tidak memiliki nilai konkurensi awal yang disediakan, Application Auto Scaling mungkin tidak menangani penskalaan fungsi dengan benar.
### Penskalaan terjadwal
Dengan Application Auto Scaling, Anda dapat mengatur jadwal penskalaan Anda sendiri sesuai dengan perubahan beban yang dapat diprediksi. Untuk informasi dan contoh selengkapnya, lihat [Penskalaan terjadwal untuk Application Auto](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-scheduled-scaling.html) Scaling di Panduan Pengguna Application Auto Scaling[, AWS Lambda dan Scheduling Provisioned Concurrency](https://aws.amazon.com/blogs/compute/scheduling-aws-lambda-provisioned-concurrency-for-recurring-peak-usage/) untuk penggunaan puncak berulang di Blog Komputasi. AWS
### Pelacakan target
Dengan pelacakan target, Application Auto Scaling membuat dan mengelola serangkaian CloudWatch alarm berdasarkan cara Anda menentukan kebijakan penskalaan Anda. Ketika alarm ini diaktifkan, Application Auto Scaling secara otomatis menyesuaikan jumlah lingkungan yang dialokasikan menggunakan konkurensi yang disediakan. Gunakan pelacakan target untuk aplikasi yang tidak memiliki pola lalu lintas yang dapat diprediksi.
Untuk menskalakan konkurensi yang disediakan menggunakan pelacakan target, gunakan operasi Application Auto Scaling API `RegisterScalableTarget` dan Application Auto `PutScalingPolicy` Scaling. Misalnya, jika Anda menggunakan AWS Command Line Interface (CLI), ikuti langkah-langkah berikut:
1. Daftarkan alias fungsi sebagai target penskalaan. Contoh berikut mendaftarkan alias BLUE dari fungsi bernama: `my-function`
```
aws application-autoscaling register-scalable-target --service-namespace lambda \
--resource-id function:my-function:BLUE --min-capacity 1 --max-capacity 100 \
--scalable-dimension lambda:function:ProvisionedConcurrency
```
1. Terapkan kebijakan penskalaan ke target. Contoh berikut mengonfigurasi Application Auto Scaling untuk menyesuaikan konfigurasi konkurensi yang disediakan untuk alias agar pemanfaatan tetap mendekati 70 persen, tetapi Anda dapat menerapkan nilai apa pun antara 10% dan 90%.
```
aws application-autoscaling put-scaling-policy \
--service-namespace lambda \
--scalable-dimension lambda:function:ProvisionedConcurrency \
--resource-id function:my-function:BLUE \
--policy-name my-policy \
--policy-type TargetTrackingScaling \
--target-tracking-scaling-policy-configuration '{ "TargetValue": 0.7, "PredefinedMetricSpecification": { "PredefinedMetricType": "LambdaProvisionedConcurrencyUtilization" }}'
```
Anda akan melihat output seperti ini:
```
{
"PolicyARN": "arn:aws:autoscaling:us-east-2:123456789012:scalingPolicy:12266dbb-1524-xmpl-a64e-9a0a34b996fa:resource/lambda/function:my-function:BLUE:policyName/my-policy",
"Alarms": [
{
"AlarmName": "TargetTracking-function:my-function:BLUE-AlarmHigh-aed0e274-xmpl-40fe-8cba-2e78f000c0a7",
"AlarmARN": "arn:aws:cloudwatch:us-east-2:123456789012:alarm:TargetTracking-function:my-function:BLUE-AlarmHigh-aed0e274-xmpl-40fe-8cba-2e78f000c0a7"
},
{
"AlarmName": "TargetTracking-function:my-function:BLUE-AlarmLow-7e1a928e-xmpl-4d2b-8c01-782321bc6f66",
"AlarmARN": "arn:aws:cloudwatch:us-east-2:123456789012:alarm:TargetTracking-function:my-function:BLUE-AlarmLow-7e1a928e-xmpl-4d2b-8c01-782321bc6f66"
}
]
}
```
Application Auto Scaling membuat dua alarm masuk. CloudWatch Alarm pertama terpicu ketika pemanfaatan konkurensi yang disediakan secara konsisten melebihi 70%. Jika hal ini terjadi, Application Auto Scaling mengalokasikan lebih banyak konkurensi terprovisi untuk mengurangi penggunaan. Alarm kedua terpicu ketika pemanfaatan secara konsisten kurang dari 63% (90 persen dari target 70%). Jika hal ini terjadi, Application Auto Scaling mengurangi konkurensi terprovisi alias.
**catatan**
Lambda memancarkan `ProvisionedConcurrencyUtilization` metrik hanya ketika fungsi Anda aktif dan menerima permintaan. Selama periode tidak aktif, tidak ada metrik yang dipancarkan, dan alarm auto-scaling Anda akan memasuki status. `INSUFFICIENT_DATA` Akibatnya, Application Auto Scaling tidak akan dapat menyesuaikan konkurensi yang disediakan fungsi Anda. Ini dapat menyebabkan penagihan yang tidak terduga.
Dalam contoh berikut, fungsi menskalakan antara jumlah konkurensi terprovisi minimum dan maksimum berdasarkan penggunaan.
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/features-scaling-provisioned-auto.png)
**Legenda**
+ ![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/features-scaling-provisioned.instances.png) Instans fungsi
+ ![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/features-scaling-provisioned.open.png) Permintaan terbuka
+ ![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/features-scaling-provisioned.provisioned.png) Konkurensi terprovisi
+ ![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/features-scaling-provisioned.standard.png) Konkurensi standar
Ketika jumlah permintaan terbuka meningkat, Application Auto Scaling meningkatkan konkurensi yang disediakan dalam langkah-langkah besar hingga mencapai maksimum yang dikonfigurasi. Setelah ini, fungsi dapat terus menskalakan pada konkurensi standar tanpa syarat jika Anda belum mencapai batas konkurensi akun Anda. Saat pemanfaatan turun dan tetap rendah, Application Auto Scaling mengurangi konkurensi yang disediakan dalam langkah-langkah periodik yang lebih kecil.
Kedua alarm Application Auto Scaling menggunakan statistik rata-rata secara default. Fungsi yang mengalami semburan lalu lintas cepat mungkin tidak memicu alarm ini. Misalnya, misalkan fungsi Lambda Anda dijalankan dengan cepat (yaitu 20-100 ms) dan lalu lintas Anda datang dalam ledakan cepat. Dalam hal ini, jumlah permintaan melebihi konkurensi yang disediakan yang dialokasikan selama burst. Namun, Application Auto Scaling membutuhkan beban burst untuk bertahan setidaknya selama 3 menit untuk menyediakan lingkungan tambahan. Selain itu, kedua CloudWatch alarm memerlukan 3 titik data yang mencapai rata-rata target untuk mengaktifkan kebijakan penskalaan otomatis. Jika fungsi Anda mengalami ledakan lalu lintas yang cepat, menggunakan statistik **Maksimum** alih-alih statistik **Rata-rata** dapat lebih efektif dalam menskalakan konkurensi yang disediakan untuk meminimalkan start dingin.
Untuk informasi selengkapnya tentang kebijakan penskalaan pelacakan target, lihat Kebijakan [penskalaan pelacakan target untuk Application Auto Scaling](https://docs.aws.amazon.com/autoscaling/application/userguide/application-auto-scaling-target-tracking.html).
# Perilaku penskalaan Lambda
Saat fungsi Anda menerima lebih banyak permintaan, Lambda secara otomatis meningkatkan jumlah lingkungan eksekusi untuk menangani permintaan ini hingga akun Anda mencapai kuota konkurensinya. Namun, untuk melindungi dari penskalaan berlebih sebagai respons terhadap ledakan lalu lintas yang tiba-tiba, Lambda membatasi seberapa cepat fungsi Anda dapat menskalakan. Tingkat **penskalaan konkurensi ini adalah tingkat** maksimum di mana fungsi di akun Anda dapat menskalakan sebagai respons terhadap peningkatan permintaan. (Artinya, seberapa cepat Lambda dapat membuat lingkungan eksekusi baru.) Tingkat penskalaan konkurensi berbeda dari batas konkurensi tingkat akun, yang merupakan jumlah total konkurensi yang tersedia untuk fungsi Anda.
## Tingkat penskalaan konkurensi
**Di masing-masing Wilayah AWS, dan untuk setiap fungsi, tingkat penskalaan konkurensi Anda adalah 1.000 instance lingkungan eksekusi setiap 10 detik (atau 10.000 permintaan per detik setiap 10 detik).** Dengan kata lain, setiap 10 detik, Lambda dapat mengalokasikan paling banyak 1.000 instance lingkungan eksekusi tambahan, atau mengakomodasi 10.000 permintaan tambahan per detik, ke setiap fungsi Anda.
Biasanya, Anda tidak perlu khawatir tentang batasan ini. Tingkat penskalaan Lambda cukup untuk sebagian besar kasus penggunaan.
Yang penting, tingkat penskalaan konkurensi adalah batas tingkat fungsi. Ini berarti bahwa setiap fungsi di akun Anda dapat menskalakan secara independen dari fungsi lainnya.
**catatan**
Dalam praktiknya, Lambda melakukan upaya terbaik untuk mengisi ulang tingkat penskalaan konkurensi Anda secara terus menerus dari waktu ke waktu, bukan dalam satu isi ulang 1.000 unit setiap 10 detik.
Lambda tidak memperoleh bagian yang tidak terpakai dari tingkat penskalaan konkurensi Anda. Ini berarti bahwa setiap saat, tingkat penskalaan Anda selalu maksimum 1.000 unit konkurensi. Misalnya, jika Anda tidak menggunakan 1.000 unit konkurensi yang tersedia dalam interval 10 detik, Anda tidak akan memperoleh 1.000 unit tambahan dalam interval 10 detik berikutnya. Tingkat penskalaan konkurensi Anda masih 1.000 dalam interval 10 detik berikutnya.
Selama fungsi Anda terus menerima peningkatan jumlah permintaan, maka Lambda menskalakan pada tingkat tercepat yang tersedia untuk Anda, hingga batas konkurensi akun Anda. Anda dapat membatasi jumlah konkurensi yang dapat digunakan oleh masing-masing fungsi dengan [mengonfigurasi konkurensi cadangan](configuration-concurrency.md). Jika permintaan masuk lebih cepat dari skala fungsi Anda, atau jika fungsi Anda berada pada konkurensi maksimum, maka permintaan tambahan gagal dengan kesalahan pelambatan (429 kode status).
# Memantau konkurensi
Lambda memancarkan metrik CloudWatch Amazon untuk membantu Anda memantau konkurensi fungsi Anda. Topik ini menjelaskan metrik ini dan cara menafsirkannya.
**Topics**
+ [Metrik konkurensi umum](#general-concurrency-metrics)
+ [Metrik konkurensi terprovisi](#provisioned-concurrency-metrics)
+ [Bekerja dengan `ClaimedAccountConcurrency` metrik](#claimed-account-concurrency)
## Metrik konkurensi umum
Gunakan metrik berikut untuk memantau konkurensi fungsi Lambda Anda. Granularitas untuk setiap metrik adalah 1 menit.
+ `ConcurrentExecutions`— Jumlah pemanggilan bersamaan aktif pada titik waktu tertentu. Lambda memancarkan metrik ini untuk semua fungsi, versi, dan alias. **Untuk fungsi apa pun di konsol Lambda, Lambda menampilkan grafik `ConcurrentExecutions` secara native di tab **Pemantauan**, di bawah Metrik.** Lihat metrik ini menggunakan **MAX**.
+ `UnreservedConcurrentExecutions`— Jumlah pemanggilan bersamaan aktif yang menggunakan konkurensi tanpa syarat. Lambda memancarkan metrik ini di semua fungsi di suatu wilayah. Lihat metrik ini menggunakan **MAX**.
+ `ClaimedAccountConcurrency`— Jumlah konkurensi yang tidak tersedia untuk pemanggilan sesuai permintaan. `ClaimedAccountConcurrency`sama dengan `UnreservedConcurrentExecutions` ditambah jumlah konkurensi yang dialokasikan (yaitu total konkurensi cadangan ditambah total konkurensi yang disediakan). Jika `ClaimedAccountConcurrency` melebihi batas konkurensi akun Anda, Anda dapat [meminta batas konkurensi akun yang lebih tinggi](https://aws.amazon.com/premiumsupport/knowledge-center/lambda-concurrency-limit-increase/). Lihat metrik ini menggunakan **MAX**. Untuk informasi selengkapnya, lihat [Bekerja dengan `ClaimedAccountConcurrency` metrik](#claimed-account-concurrency).
## Metrik konkurensi terprovisi
Gunakan metrik berikut untuk memantau fungsi Lambda menggunakan konkurensi yang disediakan. Granularitas untuk setiap metrik adalah 1 menit.
+ `ProvisionedConcurrentExecutions`— Jumlah instance lingkungan eksekusi yang secara aktif memproses pemanggilan pada konkurensi yang disediakan. Lambda memancarkan metrik ini untuk setiap versi fungsi dan alias dengan konkurensi yang disediakan yang dikonfigurasi. Lihat metrik ini menggunakan **MAX**.
`ProvisionedConcurrentExecutions`tidak sama dengan jumlah total konkurensi yang disediakan yang Anda alokasikan. Misalnya, Anda mengalokasikan 100 unit konkurensi yang disediakan ke versi fungsi. Selama menit tertentu, jika paling banyak 50 dari 100 lingkungan eksekusi tersebut menangani pemanggilan secara bersamaan, maka nilai **MAX** (`ProvisionedConcurrentExecutions`) adalah 50.
+ `ProvisionedConcurrencyInvocations`— Berapa kali Lambda memanggil kode fungsi Anda menggunakan konkurensi yang disediakan. Lambda memancarkan metrik ini untuk setiap versi fungsi dan alias dengan konkurensi yang disediakan yang dikonfigurasi. Lihat metrik ini menggunakan **SUM**.
`ProvisionedConcurrencyInvocations`berbeda dari `ProvisionedConcurrentExecutions` yang `ProvisionedConcurrencyInvocations` menghitung jumlah total pemanggilan, sementara `ProvisionedConcurrentExecutions` menghitung jumlah lingkungan aktif. Untuk memahami perbedaan ini, pertimbangkan skenario berikut:
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/concurrency-metrics-pc-executions-vs-invocations.png)
Dalam contoh ini, misalkan Anda menerima 1 doa per menit, dan setiap doa membutuhkan waktu 2 menit untuk menyelesaikannya. Setiap bar horisontal oranye mewakili satu permintaan. Misalkan Anda mengalokasikan 10 unit konkurensi yang disediakan untuk fungsi ini, sehingga setiap permintaan berjalan pada konkurensi yang disediakan.
Di antara menit 0 dan 1, `Request 1` masuk. **Pada menit 1**, nilai untuk **MAX** (`ProvisionedConcurrentExecutions`) adalah 1, karena paling banyak 1 lingkungan eksekusi aktif selama beberapa menit terakhir. Nilai untuk **SUM** (`ProvisionedConcurrencyInvocations`) juga 1, karena 1 permintaan baru masuk selama beberapa menit terakhir.
Di antara menit 1 dan 2, `Request 2` masuk, dan `Request 1` terus berjalan. **Pada menit 2**, nilai untuk **MAX** (`ProvisionedConcurrentExecutions`) adalah 2, karena paling banyak 2 lingkungan eksekusi aktif selama beberapa menit terakhir. Namun, nilai untuk **SUM** (`ProvisionedConcurrencyInvocations`) adalah 1, karena hanya 1 permintaan baru yang masuk selama beberapa menit terakhir. Perilaku metrik ini berlanjut hingga akhir contoh.
+ `ProvisionedConcurrencySpilloverInvocations`— Berapa kali Lambda memanggil fungsi Anda pada konkurensi standar (reserved atau unreserved) saat semua konkurensi yang disediakan sedang digunakan. Lambda memancarkan metrik ini untuk setiap versi fungsi dan alias dengan konkurensi yang disediakan yang dikonfigurasi. Lihat metrik ini menggunakan **SUM**. Nilai `ProvisionedConcurrencyInvocations` \$1 `ProvisionedConcurrencySpilloverInvocations` harus sama dengan jumlah total pemanggilan fungsi (yaitu `Invocations` metrik).
`ProvisionedConcurrencyUtilization`— Persentase konkurensi yang disediakan yang digunakan (yaitu nilai `ProvisionedConcurrentExecutions` dibagi dengan jumlah total konkurensi yang disediakan yang dialokasikan). Lambda memancarkan metrik ini untuk setiap versi fungsi dan alias dengan konkurensi yang disediakan yang dikonfigurasi. Lihat metrik ini menggunakan **MAX**.
Misalnya, Anda menyediakan 100 unit konkurensi yang disediakan ke versi fungsi. Selama menit tertentu, jika paling banyak 60 dari 100 lingkungan eksekusi tersebut menangani pemanggilan secara bersamaan, maka nilai **MAX** (`ProvisionedConcurrentExecutions`) adalah 60, dan nilai **MAX** (`ProvisionedConcurrencyUtilization`) adalah 0,6.
Nilai tinggi untuk `ProvisionedConcurrencySpilloverInvocations` mungkin menunjukkan bahwa Anda perlu mengalokasikan konkurensi tambahan yang disediakan untuk fungsi Anda. Atau, Anda dapat [mengonfigurasi Application Auto Scaling untuk menangani penskalaan otomatis konkurensi yang disediakan berdasarkan ambang batas yang telah ditentukan sebelumnya](https://docs.aws.amazon.com/lambda/latest/dg/provisioned-concurrency.html#managing-provisioned-concurency).
Sebaliknya, nilai rendah secara konsisten untuk `ProvisionedConcurrencyUtilization` dapat menunjukkan bahwa Anda mengalokasikan konkurensi yang disediakan secara berlebihan untuk fungsi Anda.
## Bekerja dengan `ClaimedAccountConcurrency` metrik
Lambda menggunakan `ClaimedAccountConcurrency` metrik untuk menentukan berapa banyak konkurensi akun Anda tersedia untuk pemanggilan sesuai permintaan. Lambda menghitung `ClaimedAccountConcurrency` menggunakan rumus berikut:
```
ClaimedAccountConcurrency = UnreservedConcurrentExecutions + (allocated concurrency)
```
`UnreservedConcurrentExecutions`adalah jumlah pemanggilan bersamaan aktif yang menggunakan konkurensi tanpa syarat. Konkurensi yang dialokasikan adalah jumlah dari dua bagian berikut (diganti sebagai “konkurensi cadangan” dan `RC` `PC` sebagai “konkurensi yang disediakan”):
+ Total `RC` di semua fungsi di suatu Wilayah.
+ Total `PC` di semua fungsi di Wilayah yang menggunakan`PC`, tidak termasuk fungsi yang digunakan`RC`.
**catatan**
Anda tidak dapat mengalokasikan `PC` lebih dari `RC` untuk suatu fungsi. Dengan demikian, fungsi selalu `RC` lebih besar dari atau sama dengan fungsinya`PC`. Untuk menghitung kontribusi konkurensi yang dialokasikan untuk fungsi-fungsi tersebut dengan keduanya `PC` dan, `RC` Lambda hanya mempertimbangkan`RC`, yang merupakan maksimum dari keduanya.
Lambda menggunakan `ClaimedAccountConcurrency` metrik, bukan`ConcurrentExecutions`, untuk menentukan berapa banyak konkurensi yang tersedia untuk pemanggilan sesuai permintaan. Meskipun `ConcurrentExecutions` metrik berguna untuk melacak jumlah pemanggilan bersamaan yang aktif, metrik tidak selalu mencerminkan ketersediaan konkurensi Anda yang sebenarnya. Ini karena Lambda juga mempertimbangkan konkurensi cadangan dan konkurensi yang disediakan untuk menentukan ketersediaan.
Sebagai ilustrasi`ClaimedAccountConcurrency`, pertimbangkan skenario di mana Anda mengonfigurasi banyak konkurensi cadangan dan konkurensi yang disediakan di seluruh fungsi Anda yang sebagian besar tidak digunakan. Dalam contoh berikut, asumsikan bahwa batas konkurensi akun Anda adalah 1.000, dan Anda memiliki dua fungsi utama di akun Anda: `function-orange` dan`function-blue`. Anda mengalokasikan 600 unit konkurensi cadangan untuk. `function-orange` Anda mengalokasikan 200 unit konkurensi yang disediakan untuk. `function-blue` Misalkan seiring waktu, Anda menerapkan fungsi tambahan dan mengamati pola lalu lintas berikut:
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/claimed-account-concurrency.png)
Pada diagram sebelumnya, garis hitam menunjukkan penggunaan konkurensi aktual dari waktu ke waktu, dan garis merah menunjukkan nilai dari waktu `ClaimedAccountConcurrency` ke waktu. Sepanjang skenario `ClaimedAccountConcurrency` ini, minimal 800, meskipun pemanfaatan konkurensi aktual rendah di seluruh fungsi Anda. Ini karena Anda mengalokasikan total 800 unit konkurensi untuk `function-orange` dan. `function-blue` Dari perspektif Lambda, Anda telah “mengklaim” konkurensi ini untuk digunakan, sehingga Anda secara efektif hanya memiliki 200 unit konkurensi yang tersisa untuk fungsi lain.
Untuk skenario ini, konkurensi yang dialokasikan adalah 800 dalam rumus. `ClaimedAccountConcurrency` Kita kemudian dapat memperoleh nilai `ClaimedAccountConcurrency` pada berbagai titik dalam diagram:
+ Pada`t1`, `ClaimedAccountConcurrency` adalah 800 (800 \$1 0`UnreservedConcurrentExecutions`).
+ Pada`t2`, `ClaimedAccountConcurrency` adalah 900 (800 \$1 100`UnreservedConcurrentExecutions`).
+ Pada`t3`, `ClaimedAccountConcurrency` lagi 900 (800 \$1 100`UnreservedConcurrentExecutions`).
### Menyiapkan `ClaimedAccountConcurrency` metrik di CloudWatch
Lambda memancarkan metrik di. `ClaimedAccountConcurrency` CloudWatch Gunakan metrik ini bersama dengan nilai `SERVICE_QUOTA(ConcurrentExecutions)` untuk mendapatkan persentase pemanfaatan konkurensi di akun Anda, seperti yang ditunjukkan dalam rumus berikut:
```
Utilization = (ClaimedAccountConcurrency/SERVICE_QUOTA(ConcurrentExecutions)) * 100%
```
Screenshot berikut menggambarkan bagaimana Anda dapat membuat grafik rumus ini. CloudWatch `claim_utilization`Garis hijau mewakili pemanfaatan konkurensi dalam akun ini, yaitu sekitar 40%:
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/claimed-account-concurrency-cloudwatch-graph.png)
Tangkapan layar sebelumnya juga menyertakan CloudWatch alarm yang masuk ke `ALARM` status ketika pemanfaatan konkurensi melebihi 70%. Anda dapat menggunakan `ClaimedAccountConcurrency` metrik bersama dengan alarm serupa untuk secara proaktif menentukan kapan Anda mungkin perlu meminta batas konkurensi akun yang lebih tinggi.