Provisioned Concurrency pada AWS Lambda

Provisioned Concurrency adalah fitur pada AWS Lambda yang memungkinkan Anda untuk memanaskan awal sejumlah instance dari fungsi Lambda Anda, sehingga mengurangi laten yang terkait dengan cold start. Cold start terjadi ketika fungsi Lambda diinisialisasi untuk pertama kali atau ketika terjadi lonjakan permintaan yang melebihi jumlah instance yang tersedia. Dengan Provisioned Concurrency, Anda dapat mempertahankan kumpulan instance yang dipanaskan awal untuk meminimalkan laten cold start dan memastikan waktu respon yang konsisten dan cepat.

Manfaat utama dari penggunaan Provisioned Concurrency pada AWS Lambda adalah:

• Mengurangi Laten
  Dengan memanaskan awal instance fungsi Lambda, waktu yang dibutuhkan untuk melayani permintaan signifikan berkurang, menghasilkan pengalaman pengguna yang lebih cepat dan konsisten.

• Performa yang Dapat Diprediksi
  Provisioned Concurrency memastikan bahwa aplikasi Anda memiliki kumpulan resource yang konstan untuk menangani permintaan, menghilangkan kebutuhan untuk meningkatkan kapasitas on-demand dan memberikan tingkat performa yang dapat diprediksi.

• Kontrol yang Lebih Baik
  Anda dapat mengonfigurasi jumlah instance yang dipanaskan awal berdasarkan kebutuhan aplikasi Anda, memberikan Anda kontrol yang lebih baik atas performa dan biaya aplikasi Anda.

Kapan Menggunakan Provisioned Concurrency

Provisioned Concurrency paling bermanfaat untuk aplikasi yang memerlukan respon laten yang rendah dan memiliki pola beban kerja yang dapat diprediksi. Kasus penggunaan meliputi:

• Aplikasi Interaktif
  Aplikasi seperti aplikasi web atau mobile, di mana pengguna mengharapkan waktu respon yang cepat dan konsisten, dapat sangat diuntungkan dari Provisioned Concurrency.

• Pekerjaan Terjadwal
  Jika Anda memiliki fungsi Lambda yang berjalan sebagai pekerjaan terjadwal atau tugas cron, Anda dapat menggunakan Provisioned Concurrency untuk memastikan bahwa fungsi tersebut mulai dieksekusi segera setelah dipicu.

• Layanan High-Throughput
  Untuk layanan yang perlu memproses volume permintaan yang tinggi dengan laten yang rendah, Provisioned Concurrency dapat membantu mempertahankan performa yang stabil.

Namun, penting untuk dicatat bahwa Provisioned Concurrency mungkin tidak cocok untuk semua skenario, terutama jika aplikasi Anda memiliki beban kerja yang sangat bervariasi atau tidak dapat diprediksi, karena ini dapat menyebabkan peningkatan biaya.

Memahami Model Harga

Ketika menggunakan Provisioned Concurrency, Anda akan dikenakan biaya berdasarkan jumlah instance yang dipanaskan awal yang Anda konfigurasi dan durasi yang dipesan. Biaya dihitung menggunakan komponen-komponen berikut:

• Provisioned Concurrency
  Anda dikenakan biaya untuk jumlah instance yang dipanaskan awal yang Anda konfigurasi, terlepas dari apakah mereka digunakan atau tidak.

• Durasi
  Anda dikenakan biaya untuk total durasi instance yang dipanaskan awal Anda, diukur dalam GB-sekon. Ini dihitung sebagai hasil kali ukuran memori fungsi Anda, jumlah instance yang dipanaskan awal, dan durasi yang dipesan.

• Request
  Anda juga dikenakan biaya untuk jumlah request yang dilayani oleh fungsi Lambda Anda, termasuk instance yang dipanaskan awal dan on-demand.

Sangat penting untuk mempertimbangkan implikasi harga dengan cermat sebelum menerapkan Provisioned Concurrency. Untuk mengoptimalkan biaya, Anda harus menganalisis pola beban kerja aplikasi Anda dan mengonfigurasi jumlah instance yang dipanaskan awal sesuai dengan kebutuhan. Ingatlah bahwa memiliki terlalu banyak instance yang tidak digunakan dapat menyebabkan biaya yang lebih tinggi, sementara memiliki terlalu sedikit instance dapat mengakibatkan cold start dan laten yang lebih tinggi.

Example Monthly Charge

Let's assume you have a Lambda function with a memory size of 1.5 GB and you've configured 20 instances of Provisioned Concurrency. The function is provisioned for an entire month (30 days), and during that time, it serves 25 million requests.

In this example, we'll use the pricing for the US East (N. Virginia) region, which is $0.015 per GB-hour for Provisioned Concurrency and $0.20 per 1 million requests.

• Provisioned Concurrency cost: To calculate the total cost for Provisioned Concurrency, we first need to determine the GB-hours. Since each instance has 1.5 GB of memory and there are 20 instances provisioned for 30 days, the calculation is:
  • GB-hours = 1.5 GB * 20 instances * 24 hours/day * 30 days = 21600 GB-hours
  • Provisioned Concurrency cost = 21600 GB-hours * $0.015/GB-hour = $324
• Request cost: The cost for 25 million requests is:
  • Requests cost = 25 million requests * ($0.20/1 million requests) = $5

The total monthly charge for this example would be $329 (Provisioned Concurrency cost + Requests cost).

Contoh Biaya Bulanan:

Misalkan Anda memiliki fungsi Lambda dengan ukuran memori 1,5 GB dan Anda telah mengonfigurasi 20 instance Provisioned Concurrency. Fungsi tersebut dipanaskan selama sebulan penuh (30 hari), dan selama itu, melayani 25 juta permintaan.

Dalam contoh ini, kita akan menggunakan harga untuk wilayah AS Timur Laut (Virginia Utara), yaitu $0,015 per GB-jam untuk Provisioned Concurrency dan $0,20 per 1 juta permintaan.

• Biaya Provisioned Concurrency: Untuk menghitung total biaya Provisioned Concurrency, pertama-tama kita perlu menentukan GB-jam. Karena setiap instance memiliki memori 1,5 GB dan ada 20 instance yang dipanaskan awal selama 30 hari, perhitungannya adalah sebagai berikut:
  • GB-jam = 1,5 GB * 20 instance * 24 jam/hari * 30 hari = 21.600 GB-jam
  • Biaya Provisioned Concurrency = 21.600 GB-jam * $0,015/GB-jam = $324
• Biaya request: Biaya untuk 25 juta request adalah:
  • Biaya Permintaan = 25 juta request * ($0,20/1 juta request) = $5

Total biaya bulanan untuk contoh ini adalah $329 (biaya Provisioned Concurrency + biaya request).

Mengonfigurasi Provisioned Concurrency

Mengatur Provisioned Concurrency pada AWS Console

Untuk mengonfigurasi Provisioned Concurrency untuk fungsi Lambda menggunakan AWS Management Console, ikuti langkah-langkah berikut:

1. Buka AWS Management Console dan masuk ke akun Anda.
2. Buka layanan AWS Lambda dengan mencari Lambda pada kolom pencarian atau memilihnya dari menu Services.
3. Cari fungsi Lambda yang diinginkan dalam daftar dan klik namanya untuk membuka halaman konfigurasi fungsi.
4. Di panel Function Configuration, pilih tab Versions.
5. Pilih versi atau alias dari fungsi Lambda Anda yang ingin Anda aktifkan Provisioned Concurrency.
6. Gulir ke bawah ke bagian Provisioned Concurrency dan klik Edit.
7. Masukkan jumlah instance yang dipanaskan awal yang diinginkkan dalam kotak masukan Provisioned Concurrency.
8. Klik Save untuk menerapkan perubahan.

Setelah konfigurasi disimpan, AWS akan mulai memanaskan jumlah instance yang ditentukan untuk fungsi Lambda Anda.

Menggunakan AWS CLI dan SDK

Anda juga dapat mengonfigurasi Provisioned Concurrency menggunakan Command Line Interface (CLI) atau SDK AWS. Untuk mengatur Provisioned Concurrency menggunakan AWS CLI, jalankan perintah berikut:

$ aws lambda put-provisioned-concurrency-config \
  --function-name <FUNCTION_NAME> \
  --qualifier <VERSION_OR_ALIAS> \
  --provisioned-concurrent-executions <NUMBER_OF_INSTANCES>

Ganti <FUNCTION_NAME> dengan nama fungsi Lambda Anda, <VERSION_OR_ALIAS> dengan versi atau alias yang diinginkan, dan <NUMBER_OF_INSTANCES> dengan jumlah instance yang dipanaskan awal yang ingin Anda konfigurasi.

Untuk mengonfigurasi Provisioned Concurrency menggunakan SDK, lihat dokumentasi yang relevan untuk SDK dalam bahasa pemrograman yang Anda sukai.

Mengelola Provisioned Concurrency dengan Infrastructure as Code

Alat Infrastructure as Code (IaC) seperti AWS CloudFormation dan Terraform memungkinkan Anda mengelola dan mengotomatiskan konfigurasi resource AWS Anda, termasuk Provisioned Concurrency untuk fungsi Lambda. Berikut ini contoh cara mengonfigurasi Provisioned Concurrency menggunakan AWS CloudFormation:

Resources:
  MyLambdaFunction:
    Type: AWS::Lambda::Function
    Properties:
      # Function properties...

  MyLambdaFunctionProvisionedConcurrency:
    Type: AWS::Lambda::ProvisionedConcurrencyConfig
    Properties:
      FunctionName: !Ref MyLambdaFunction
      Qualifier: <VERSION_OR_ALIAS>
      ProvisionedConcurrentExecutions: <NUMBER_OF_INSTANCES>

Ganti <VERSION_OR_ALIAS> dengan versi atau alias yang diinginkan, dan <NUMBER_OF_INSTANCES> dengan jumlah instance yang dipanaskan awal yang ingin Anda konfigurasi.

Untuk Terraform, Anda dapat menggunakan resource aws_lambda_provisioned_concurrency_config untuk mengonfigurasi Provisioned Concurrency:

resource "aws_lambda_function" "my_lambda_function" {
  # Function properties...
}

resource "aws_lambda_provisioned_concurrency_config" "my_lambda_function_provisioned_concurrency" {
  function_name                     = aws_lambda_function.my_lambda_function.function_name
  provisioned_concurrent_executions = <NUMBER_OF_INSTANCES>
  qualifier                         = <VERSION_OR_ALIAS>
}

Ganti <VERSION_OR_ALIAS> dengan versi atau alias yang diinginkan, dan <NUMBER_OF_INSTANCES> dengan jumlah instance yang dipanaskan awal yang ingin Anda konfigurasi.

Membandingkan Efek Global Scope

Di AWS Lambda, global scope merujuk pada variabel, objek, atau resource yang didefinisikan di luar pengelola fungsi Lambda. Variabel global scope diinisialisasi saat wadah fungsi Lambda dibuat dan digunakan kembali pada beberapa panggilan yang sama dari wadah yang sama. Global scope dapat mempengaruhi kinerja fungsi Lambda Anda, terutama saat menggunakan Provisioned Concurrency.

Mari kita bandingkan efek global scope dengan contoh:

import boto3

# Global scope variable
dynamodb = boto3.resource("dynamodb")
table = dynamodb.Table("MyTable")

def lambda_handler(event, context):
    # Function scope variable
    s3 = boto3.client("s3")

    # Function logic...

Pada contoh ini, resource dynamodb dan variabel table berada di global scope, sementara klien s3 berada di function scope. Ketika menggunakan Provisioned Concurrency, variabel global scope diinisialisasi hanya sekali saat kontainer dibuat. Ini berarti bahwa resource dan tabel DynamoDB tersedia untuk semua panggilan dari wadah yang sama, mengurangi overhead inisialisasi untuk panggilan berikutnya.

Di sisi lain, klien s3 diinisialisasi untuk setiap panggilan, yang dapat menyebabkan peningkatan laten. Namun, hal ini dapat diabaikan untuk kasus penggunaan yang jarang atau dengan throughput yang rendah.

Inisialisasi Statis dan Provisioned Concurrency

Inisialisasi statis merujuk pada proses menginisialisasi resource, modul, atau data selama fase startup kontainer fungsi Lambda. Ini dapat memiliki dampak signifikan pada waktu laten cold start, terutama untuk aplikasi yang kompleks atau berintensitas resource.

Ketika menggunakan Provisioned Concurrency, inisialisasi statis terjadi saat instance pre-warmed dibuat. Ini memungkinkan fungsi Lambda untuk memulai dengan resource, modul, dan data yang sudah diinisialisasi, mengurangi laten untuk setiap panggilan.

Mari kita pertimbangkan contoh di mana kita menggunakan inisialisasi statis untuk memuat model machine learning:

import json
import boto3
import numpy as np
from sklearn.externals import joblib

# Static initialization
s3 = boto3.client("s3")
s3.download_file("my-bucket", "models/model.pkl", "/tmp/model.pkl")
model = joblib.load("/tmp/model.pkl")

def lambda_handler(event, context):
    # Function logic
    input_data = np.array(json.loads(event["body"])["input"])
    prediction = model.predict(input_data)

    return {
        "statusCode": 200,
        "body": json.dumps({"prediction": prediction.tolist()})
    }

Pada contoh ini, model machine learning diunduh dan dimuat selama fase inisialisasi statis. Ketika menggunakan Provisioned Concurrency, model sudah dimuat dan tersedia untuk semua panggilan, menghasilkan waktu respons yang lebih cepat.

Memanggil Fungsi Lambda dengan Versi atau Alias untuk Provisioned Concurrency

Untuk mendapatkan manfaat dari Provisioned Concurrency, Anda perlu memanggil versi atau alias yang spesifik dari fungsi Lambda untuk yang Anda telah mengonfigur instansi pre-warmed. Bab ini menjelaskan cara memanggil fungsi Lambda menggunakan versi atau alias untuk memanfaatkan provisioned concurrency.

Memanggil Fungsi Lambda dengan Versi

Versi fungsi Lambda adalah snapshot tidak dapat diubah dari kode dan konfigurasi fungsi Anda. Untuk memanggil versi spesifik dari fungsi Lambda, Anda perlu menambahkan nomor versi ke nama fungsi dengan menggunakan sintaks :nomor_versi.

Contoh memanggil versi spesifik menggunakan AWS CLI:

$ aws lambda invoke --function-name <NAMA_FUNGSI>:<NOMOR_VERSI> --payload '{"key": "value"}' response.json

Ganti <NAMA_FUNGSI> dengan nama fungsi Lambda Anda dan <NOMOR_VERSI> dengan nomor versi untuk yang Anda telah mengonfigurasi provisioned concurrency.

Memanggil Fungsi Lambda dengan Alias

Alias adalah referensi bernama ke versi fungsi yang spesifik. Menggunakan alias dapat menyederhanakan proses pengiriman dan pemanggilan fungsi Anda. Anda dapat membuat alias untuk versi fungsi Lambda Anda dengan provisioned concurrency, dan kemudian memperbarui alias tersebut ketika ingin beralih ke versi baru.

Contoh memanggil fungsi Lambda menggunakan alias dengan AWS CLI:

$ aws lambda invoke --function-name <FUNCTION_NAME>:<ALIAS_NAME> --payload '{"key": "value"}' response.json

Ganti <NAMA_FUNGSI> dengan nama fungsi Lambda Anda dan <NAMA_ALIAS> dengan nama alias yang Anda telah konfigurasi provisioned concurrency.

Referensi

https://docs.aws.amazon.com/lambda/latest/dg/provisioned-concurrency.html
https://docs.aws.amazon.com/lambda/latest/operatorguide/global-scope.html
https://www.youtube.com/watch?v=7Bc97tAySkU&ab_channel=CloudWithRaj