

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

# Mengelola dependensi Lambda dengan lapisan
<a name="chapter-layers"></a>

Lapisan Lambda adalah arsip file.zip yang berisi kode atau data tambahan. Lapisan biasanya berisi dependensi pustaka, [runtime kustom](runtimes-custom.md), atau file konfigurasi. 

Ada beberapa alasan mengapa Anda mungkin mempertimbangkan untuk menggunakan lapisan:
+ **Untuk mengurangi ukuran paket penyebaran Anda.** Alih-alih memasukkan semua dependensi fungsi Anda bersama dengan kode fungsi Anda dalam paket penerapan Anda, letakkan di lapisan. Ini membuat paket penerapan tetap kecil dan terorganisir.
+ **Untuk memisahkan logika fungsi inti dari dependensi.** Dengan lapisan, Anda dapat memperbarui dependensi fungsi Anda secara independen dari kode fungsi Anda, dan sebaliknya. Ini mempromosikan pemisahan kekhawatiran dan membantu Anda fokus pada logika fungsi Anda.
+ **Untuk berbagi dependensi di beberapa fungsi.** Setelah Anda membuat layer, Anda dapat menerapkannya ke sejumlah fungsi di akun Anda. Tanpa lapisan, Anda perlu menyertakan dependensi yang sama di setiap paket penerapan individu.
+ **Untuk menggunakan editor kode konsol Lambda.** Editor kode adalah alat yang berguna untuk menguji pembaruan kode fungsi minor dengan cepat. Namun, Anda tidak dapat menggunakan editor jika ukuran paket penerapan Anda terlalu besar. Menggunakan lapisan mengurangi ukuran paket Anda dan dapat membuka kunci penggunaan editor kode.
+ **Untuk mengunci versi SDK yang disematkan.** Tertanam SDKs dapat berubah tanpa pemberitahuan saat AWS merilis layanan dan fitur baru. Anda dapat mengunci versi SDK dengan [membuat layer Lambda](#chapter-layers) dengan versi spesifik yang diperlukan. Fungsi kemudian selalu menggunakan versi di lapisan, bahkan jika versi yang disematkan dalam layanan berubah.

Jika Anda bekerja dengan fungsi Lambda di Go atau Rust, kami sarankan untuk tidak menggunakan lapisan. Untuk fungsi Go dan Rust, Anda memberikan kode fungsi Anda sebagai executable, yang mencakup kode fungsi yang dikompilasi bersama dengan semua dependensinya. Menempatkan dependensi Anda dalam lapisan memaksa fungsi Anda untuk memuat rakitan tambahan secara manual selama fase inisialisasi, yang dapat meningkatkan waktu mulai dingin. Untuk kinerja optimal untuk fungsi Go dan Rust, sertakan dependensi Anda bersama dengan paket penerapan Anda.

Diagram berikut menggambarkan perbedaan arsitektur tingkat tinggi antara dua fungsi yang berbagi dependensi. Satu menggunakan lapisan Lambda, dan yang lainnya tidak.

![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/lambda-layers-diagram.png)


Saat Anda menambahkan layer ke fungsi, Lambda mengekstrak konten layer ke dalam `/opt` direktori di lingkungan [eksekusi](lambda-runtime-environment.md) fungsi Anda. Semua runtime Lambda yang didukung secara native menyertakan jalur ke direktori tertentu di dalam direktori. `/opt` Ini memberi fungsi Anda akses ke konten lapisan Anda. Untuk informasi selengkapnya tentang jalur spesifik ini dan cara mengemas layer Anda dengan benar, lihat[Kemasan konten lapisan Anda](packaging-layers.md).

Anda dapat menyertakan hingga lima lapisan per fungsi. Selain itu, Anda dapat menggunakan lapisan hanya dengan fungsi Lambda yang [digunakan sebagai arsip file.zip.](configuration-function-zip.md) Untuk fungsi yang [didefinisikan sebagai gambar kontainer](images-create.md), paketkan runtime pilihan Anda dan semua dependensi kode saat Anda membuat gambar kontainer. Untuk informasi selengkapnya, lihat [Bekerja dengan lapisan dan ekstensi Lambda dalam gambar kontainer di](https://aws.amazon.com/blogs/compute/working-with-lambda-layers-and-extensions-in-container-images/) Blog AWS Komputasi.

**Topics**
+ [

## Cara menggunakan lapisan
](#lambda-layers-overview)
+ [

## Versi lapisan dan lapisan
](#lambda-layer-versions)
+ [

# Kemasan konten lapisan Anda
](packaging-layers.md)
+ [

# Membuat dan menghapus layer di Lambda
](creating-deleting-layers.md)
+ [

# Menambahkan lapisan ke fungsi
](adding-layers.md)
+ [

# Menggunakan AWS CloudFormation dengan lapisan
](layers-cfn.md)
+ [

# Menggunakan AWS SAM dengan lapisan
](layers-sam.md)

## Cara menggunakan lapisan
<a name="lambda-layers-overview"></a>

Untuk membuat layer, paketkan dependensi Anda ke dalam file.zip, mirip dengan cara Anda [membuat paket penerapan normal](configuration-function-zip.md). Lebih khusus lagi, proses umum membuat dan menggunakan lapisan melibatkan tiga langkah ini:
+ **Pertama, paketkan konten layer Anda.** Ini berarti membuat arsip file.zip. Untuk informasi selengkapnya, lihat [Kemasan konten lapisan Anda](packaging-layers.md).
+ **Selanjutnya, buat layer di Lambda.** Untuk informasi selengkapnya, lihat [Membuat dan menghapus layer di Lambda](creating-deleting-layers.md).
+ **Tambahkan layer ke fungsi Anda.** Untuk informasi selengkapnya, lihat [Menambahkan lapisan ke fungsi](adding-layers.md).

## Versi lapisan dan lapisan
<a name="lambda-layer-versions"></a>

Versi lapisan adalah snapshot yang tidak dapat diubah dari versi tertentu dari lapisan. Saat Anda membuat layer baru, Lambda membuat versi layer baru dengan nomor versi 1. Setiap kali Anda mempublikasikan pembaruan ke layer, Lambda menambah nomor versi dan membuat versi layer baru.

Setiap versi layer diidentifikasi oleh Amazon Resource Name (ARN) yang unik. Saat menambahkan lapisan ke fungsi, Anda harus menentukan versi lapisan yang tepat yang ingin Anda gunakan (misalnya,`arn:aws:lambda:us-east-1:123456789012:layer:my-layer:1`).

# Kemasan konten lapisan Anda
<a name="packaging-layers"></a>

Lapisan Lambda adalah arsip file.zip yang berisi kode atau data tambahan. Lapisan biasanya berisi dependensi pustaka, [runtime kustom](runtimes-custom.md), atau file konfigurasi. 

Bagian ini menjelaskan cara mengemas konten layer Anda dengan benar. Untuk informasi konseptual lebih lanjut tentang lapisan dan mengapa Anda mungkin mempertimbangkan untuk menggunakannya, lihat[Mengelola dependensi Lambda dengan lapisan](chapter-layers.md).

Langkah pertama untuk membuat layer adalah untuk menggabungkan semua konten layer Anda ke dalam arsip file.zip. Karena fungsi Lambda berjalan di [Amazon Linux](https://docs.aws.amazon.com/linux/al2023/ug/what-is-amazon-linux.html), konten layer Anda harus dapat dikompilasi dan dibangun di lingkungan Linux.

Untuk memastikan bahwa konten lapisan Anda berfungsi dengan baik di lingkungan Linux, sebaiknya buat konten lapisan Anda menggunakan alat seperti [Docker](https://docs.docker.com/get-docker).

**Topics**
+ [

## Jalur lapisan untuk setiap runtime Lambda
](#packaging-layers-paths)

## Jalur lapisan untuk setiap runtime Lambda
<a name="packaging-layers-paths"></a>

Saat Anda menambahkan lapisan ke fungsi, Lambda memuat konten lapisan ke dalam `/opt` direktori lingkungan eksekusi itu. Untuk setiap runtime Lambda, `PATH` variabel sudah menyertakan jalur folder tertentu dalam direktori. `/opt` Untuk memastikan bahwa Lambda mengambil konten layer Anda, file layer.zip Anda harus memiliki dependensinya di salah satu jalur folder berikut:

[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/packaging-layers.html)

Contoh berikut menunjukkan cara Anda dapat menyusun folder dalam arsip .zip lapisan Anda.

------
#### [ Node.js ]

**Example struktur file untuk AWS X-Ray SDK untuk Node.js**  

```
xray-sdk.zip
└ nodejs/node_modules/aws-xray-sdk
```

------
#### [ Python ]

**Example**  

```
python/              # Required top-level directory
└── requests/
└── boto3/
└── numpy/
└── (dependencies of the other packages)
```

------
#### [ Ruby ]

**Example struktur file untuk JSON gem**  

```
json.zip
└ ruby/gems/3.4.0/
               | build_info
               | cache
               | doc
               | extensions
               | gems
               | └ json-2.1.0
               └ specifications
                 └ json-2.1.0.gemspec
```

------
#### [ Java ]

**Example struktur file untuk file JAR Jackson**  

```
layer_content.zip
└ java
    └ lib
        └ jackson-core-2.17.0.jar
        └ <other potential dependencies>
        └ ...
```

------
#### [ All ]

**Example struktur file untuk pustaka jq**  

```
jq.zip
└ bin/jq
```

------

Untuk instruksi khusus bahasa tentang pengemasan, pembuatan, dan penambahan lapisan, lihat halaman berikut:
+ **Node.js** – [Bekerja dengan lapisan untuk fungsi Lambda Node.js](nodejs-layers.md)
+ **Python** – [Bekerja dengan lapisan untuk fungsi Lambda Python](python-layers.md)
+ **Ruby** – [Bekerja dengan lapisan untuk fungsi Ruby Lambda](ruby-layers.md)
+ **Jawa** — [Bekerja dengan lapisan untuk fungsi Java Lambda](java-layers.md)

Kami merekomendasikan **agar** tidak menggunakan lapisan untuk mengelola dependensi untuk fungsi Lambda yang ditulis dalam Go dan Rust. Ini karena fungsi Lambda yang ditulis dalam bahasa-bahasa ini dikompilasi menjadi satu executable, yang Anda berikan kepada Lambda ketika Anda menerapkan fungsi Anda. Executable ini berisi kode fungsi dikompilasi Anda, bersama dengan semua dependensinya. Menggunakan lapisan tidak hanya mempersulit proses ini, tetapi juga menyebabkan peningkatan waktu mulai dingin karena fungsi Anda perlu memuat rakitan ekstra secara manual ke dalam memori selama fase init.

Untuk menggunakan dependensi eksternal dengan fungsi Go dan Rust Lambda, sertakan mereka langsung dalam paket penerapan Anda.

# Membuat dan menghapus layer di Lambda
<a name="creating-deleting-layers"></a>

Lapisan Lambda adalah arsip file.zip yang berisi kode atau data tambahan. Lapisan biasanya berisi dependensi pustaka, [runtime kustom](runtimes-custom.md), atau file konfigurasi. 

Bagian ini menjelaskan cara membuat dan menghapus layer di Lambda. Untuk informasi konseptual lebih lanjut tentang lapisan dan mengapa Anda mungkin mempertimbangkan untuk menggunakannya, lihat[Mengelola dependensi Lambda dengan lapisan](chapter-layers.md).

Setelah Anda [mengemas konten layer Anda](packaging-layers.md), langkah selanjutnya adalah membuat layer di Lambda. Bagian ini menunjukkan cara membuat dan menghapus lapisan menggunakan konsol Lambda atau API Lambda saja. Untuk membuat layer menggunakan AWS CloudFormation, lihat[Menggunakan AWS CloudFormation dengan lapisan](layers-cfn.md). Untuk membuat layer menggunakan AWS Serverless Application Model (AWS SAM), lihat[Menggunakan AWS SAM dengan lapisan](layers-sam.md).

**Topics**
+ [

## Membuat lapisan
](#layers-create)
+ [

## Menghapus versi lapisan
](#layers-delete)

## Membuat lapisan
<a name="layers-create"></a>

Untuk membuat layer, Anda dapat mengunggah arsip file.zip dari mesin lokal Anda atau dari Amazon Simple Storage Service (Amazon S3). Lambda mengekstrak konten lapisan ke dalam direktori `/opt` saat menyiapkan lingkungan eksekusi untuk fungsi.

Layers dapat memiliki satu atau lebih [versi layer](chapter-layers.md#lambda-layer-versions). Saat Anda membuat lapisan, Lambda menetapkan versi lapisan ke versi 1. Anda dapat mengubah izin pada versi lapisan yang ada kapan saja. Namun, untuk memperbarui kode atau membuat perubahan konfigurasi lainnya, Anda harus membuat versi baru dari layer.

**Untuk membuat lapisan (konsol)**

1. Buka [halaman Fungsi](https://console.aws.amazon.com/lambda/home#/layers) di konsol Lambda.

1. Pilih **Buat lapisan**.

1. Di bagian **Konfigurasi lapisan**, untuk **Nama**, masukkan nama untuk lapisan Anda.

1. (Opsional) Untuk **Deskripsi**, masukkan deskripsi untuk lapisan Anda.

1. Untuk mengunggah kode lapisan Anda, lakukan salah satu hal berikut:
   + Untuk mengunggah file .zip dari komputer Anda, pilih **Unggah file .zip**. Selanjutnya, pilih **Unggah** untuk memilih file .zip lokal Anda.
   + Untuk mengunggah file dari Amazon S3, pilih **Unggah file dari Amazon S3**. Kemudian, untuk **URL tautan Amazon S3**, masukkan tautan ke file.

1. (Opsional) Untuk **arsitektur yang kompatibel**, pilih satu nilai atau kedua nilai. Untuk informasi selengkapnya, lihat [Memilih dan mengonfigurasi arsitektur set instruksi untuk fungsi Lambda Anda](foundation-arch.md).

1. (Opsional) Untuk **runtime yang Kompatibel**, pilih runtime yang kompatibel dengan layer Anda.

1. (Opsional) Untuk **lisensi**, masukkan informasi lisensi yang diperlukan.

1. Pilih **Buat**.

Atau, Anda dapat menjalankan perintah [publish-layer-version](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/publish-layer-version.html) AWS Command Line Interface (CLI). Contoh:

```
aws lambda publish-layer-version --layer-name my-layer --zip-file fileb://layer.zip --compatible-runtimes python3.14
```

Setiap kali Anda menjalankan`publish-layer-version`, Lambda membuat [versi baru dari layer.](chapter-layers.md#lambda-layer-versions)

## Menghapus versi lapisan
<a name="layers-delete"></a>

Untuk menghapus versi layer, gunakan operasi [DeleteLayerVersion](https://docs.aws.amazon.com/lambda/latest/api/API_DeleteLayerVersion.html)API. Misalnya, jalankan [delete-layer-version](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/delete-layer-version.html) AWS CLI perintah dengan nama layer dan versi layer yang ditentukan.

```
aws lambda delete-layer-version --layer-name my-layer --version-number 1
```

Saat menghapus versi lapisan, Anda tidak dapat lagi mengonfigurasi fungsi Lambda untuk menggunakannya. Namun, fungsi apa pun yang sudah menggunakan versi ini terus memiliki akses. Selain itu, Lambda tidak pernah menggunakan kembali nomor versi untuk nama lapisan.

Saat menghitung [kuota](gettingstarted-limits.md), menghapus versi lapisan berarti tidak lagi dihitung sebagai bagian dari kuota default 75 GB untuk penyimpanan fungsi dan lapisan. Namun, untuk fungsi yang menggunakan versi lapisan yang dihapus, konten lapisan masih diperhitungkan dalam kuota ukuran paket penerapan fungsi (yaitu 250MB untuk arsip file.zip).

# Menambahkan lapisan ke fungsi
<a name="adding-layers"></a>

Lapisan Lambda adalah arsip file.zip yang berisi kode atau data tambahan. Lapisan biasanya berisi dependensi pustaka, [runtime kustom](runtimes-custom.md), atau file konfigurasi. 

Bagian ini menjelaskan cara menambahkan layer ke fungsi Lambda. Untuk informasi konseptual lebih lanjut tentang lapisan dan mengapa Anda mungkin mempertimbangkan untuk menggunakannya, lihat[Mengelola dependensi Lambda dengan lapisan](chapter-layers.md).

Sebelum Anda dapat mengkonfigurasi fungsi Lambda untuk menggunakan lapisan, Anda harus:
+ [Package konten layer Anda](packaging-layers.md)
+ [Buat layer di Lambda](creating-deleting-layers.md)
+ Pastikan Anda memiliki izin untuk memanggil [GetLayerVersion](https://docs.aws.amazon.com/lambda/latest/api/API_GetLayerVersion.html)API pada versi layer. Untuk fungsi dalam Anda Akun AWS, Anda harus memiliki izin ini dalam [kebijakan pengguna](access-control-identity-based.md) Anda. Untuk menggunakan lapisan di akun lain, pemilik akun tersebut harus memberi akun Anda izin dalam [kebijakan berbasis sumber daya](access-control-resource-based.md). Sebagai contoh, lihat [Memberikan akses lapisan Lambda ke akun lain](permissions-layer-cross-account.md).

Anda dapat menambahkan hingga lima lapisan ke fungsi Lambda. Ukuran total fungsi yang belum di-zip dan semua lapisan tidak dapat melebihi kuota ukuran paket deployment yang belum di-zip sebesar 250 MB. Untuk informasi selengkapnya, lihat [Kuota Lambda](gettingstarted-limits.md).

Fungsi Anda dapat terus menggunakan versi lapisan apa pun yang telah Anda tambahkan, bahkan setelah versi lapisan itu dihapus, atau setelah izin Anda untuk mengakses lapisan dicabut. Namun, Anda tidak dapat membuat fungsi baru yang menggunakan versi lapisan yang dihapus.

**Untuk menambahkan lapisan ke fungsi**

1. Buka [halaman Fungsi](https://console.aws.amazon.com/lambda/home#/functions) di konsol Lambda.

1. Pilih fungsinya.

1. Gulir ke bawah ke bagian **Layers**, lalu pilih **Add a layer**.

1. Di bawah **Pilih layer**, pilih sumber layer:

   1. **AWS layer**: Pilih dari daftar [ekstensi AWS-managed](extensions-api-partners.md#aws-managed-extensions).

   1. **Custom layers**: Pilih layer yang dibuat di file Anda Akun AWS.

   1. **Tentukan ARN**: Untuk menggunakan lapisan [dari yang berbeda Akun AWS](permissions-layer-cross-account.md), seperti [ekstensi pihak ketiga](extensions-api-partners.md), masukkan Nama Sumber Daya Amazon (ARN).

1. Pilih **Tambahkan**.

Urutan di mana Anda menambahkan lapisan adalah urutan di mana Lambda menggabungkan konten lapisan ke dalam lingkungan eksekusi. Anda dapat mengubah urutan penggabungan lapisan menggunakan konsol.

**Untuk memperbarui urutan penggabungan lapisan untuk fungsi Anda (konsol)**

1. Buka [halaman Fungsi](https://console.aws.amazon.com/lambda/home#/functions) di konsol Lambda.

1. Pilih fungsi yang akan dikonfigurasi.

1. Di bawah **Layers**, pilih **Edit**

1. Pilih salah satu layer.

1. Pilih **Merge sebelumnya** atau **Merge nanti** untuk menyesuaikan urutan layer.

1. Pilih **Simpan**.

Lapisan berversi. Isi dari setiap versi lapisan tidak dapat diubah. Pemilik layer dapat merilis versi layer baru untuk menyediakan konten yang diperbarui. Anda dapat menggunakan konsol untuk memperbarui versi lapisan yang dilampirkan ke fungsi Anda.

**Untuk memperbarui versi lapisan untuk fungsi Anda (konsol)**

1. Buka [halaman Fungsi](https://console.aws.amazon.com/lambda/home#/layers) di konsol Lambda.

1. Pilih layer yang ingin Anda perbarui versinya.

1. Pilih tab **Fungsi menggunakan versi ini**.

1. Pilih fungsi yang ingin Anda ubah, lalu pilih **Edit**.

1. Untuk **versi Layer**, pilih versi layer yang akan diubah.

1. Pilih **fungsi Perbarui**.

Anda tidak dapat memperbarui versi lapisan fungsi di seluruh AWS akun.

## Menemukan informasi lapisan
<a name="finding-layer-information"></a>

Untuk menemukan lapisan di akun Anda yang kompatibel dengan runtime fungsi Anda, gunakan [ListLayers](https://docs.aws.amazon.com/lambda/latest/api/API_ListLayers.html)API. Misalnya, Anda dapat menggunakan perintah [list-layers (](https://docs.aws.amazon.com/cli/latest/reference/lambda/list-layers.html) AWS Command Line Interface CLI) berikut:

```
aws lambda list-layers --compatible-runtime python3.14
```

Anda akan melihat output yang serupa dengan yang berikut:

```
{
    "Layers": [
        {
            "LayerName": "my-layer",
            "LayerArn": "arn:aws:lambda:us-east-2:123456789012:layer:my-layer",
            "LatestMatchingVersion": {
                "LayerVersionArn": "arn:aws:lambda:us-east-2:123456789012:layer:my-layer:2",
                "Version": 2,
                "Description": "My layer",
                "CreatedDate": "2025-04-15T00:37:46.592+0000",
                "CompatibleRuntimes": [
                    "python3.14"
                ]
            }
        }
    ]
}
```

Untuk membuat daftar semua lapisan di akun Anda, hilangkan `--compatible-runtime` opsi. Detail respons menunjukkan versi terbaru dari setiap lapisan.

Anda juga bisa mendapatkan versi terbaru dari layer menggunakan [ListLayerVersions](https://docs.aws.amazon.com/lambda/latest/api/API_ListLayerVersions.html)API. Misalnya, Anda dapat menggunakan perintah `list-layer-versions` CLI berikut:

```
aws lambda list-layer-versions --layer-name my-layer
```

Anda akan melihat output yang serupa dengan yang berikut:

```
{
    "LayerVersions": [
        {
            "LayerVersionArn": "arn:aws:lambda:us-east-2:123456789012:layer:my-layer:2",
            "Version": 2,
            "Description": "My layer",
            "CreatedDate": "2023-11-15T00:37:46.592+0000",
            "CompatibleRuntimes": [
                "java11"
            ]
        },
        {
            "LayerVersionArn": "arn:aws:lambda:us-east-2:123456789012:layer:my-layer:1",
            "Version": 1,
            "Description": "My layer",
            "CreatedDate": "2023-11-15T00:27:46.592+0000",
            "CompatibleRuntimes": [
                "java11"
            ]
        }
    ]
}
```

# Menggunakan AWS CloudFormation dengan lapisan
<a name="layers-cfn"></a>

Anda dapat menggunakan CloudFormation untuk membuat layer dan mengaitkan layer dengan fungsi Lambda Anda. **Contoh template berikut membuat layer bernama `my-lambda-layer` dan melampirkan layer ke fungsi Lambda menggunakan properti Layers.**

Dalam contoh ini, template menentukan Amazon Resource Name (ARN) dari peran eksekusi [IAM](lambda-intro-execution-role.md) yang ada. Anda juga dapat membuat peran eksekusi baru dalam template menggunakan CloudFormation [AWS::IAM::Role](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-iam-role.html)sumber daya.

Fungsi Anda tidak memerlukan izin khusus untuk menggunakan lapisan.

```
---
Description: CloudFormation Template for Lambda Function with Lambda Layer
Resources:
  MyLambdaLayer:
    Type: AWS::Lambda::LayerVersion
    Properties:
      LayerName: my-lambda-layer
      Description: My Lambda Layer
      Content:
        S3Bucket: amzn-s3-demo-bucket
        S3Key: my-layer.zip
      CompatibleRuntimes:
        - python3.9
        - python3.10
        - python3.11

  MyLambdaFunction:
    Type: AWS::Lambda::Function
    Properties:
      FunctionName: my-lambda-function
      Runtime: python3.9
      Handler: index.handler
      Timeout: 10
      Role: arn:aws:iam::111122223333:role/my_lambda_role
      Layers:
        - !Ref MyLambdaLayer
```

# Menggunakan AWS SAM dengan lapisan
<a name="layers-sam"></a>

Anda dapat menggunakan AWS Serverless Application Model (AWS SAM) untuk mengotomatiskan pembuatan lapisan dalam aplikasi Anda. Tipe sumber daya `AWS::Serverless::LayerVersion` membuat versi lapisan yang dapat Anda referensikan dari konfigurasi fungsi Lambda Anda.

```
AWSTemplateFormatVersion: '2010-09-09'
Transform: 'AWS::Serverless-2016-10-31'
Description: AWS SAM Template for Lambda Function with Lambda Layer

Resources:
  MyLambdaLayer:
    Type: AWS::Serverless::LayerVersion
    Properties:
      LayerName: my-lambda-layer
      Description: My Lambda Layer
      ContentUri: s3://amzn-s3-demo-bucket/my-layer.zip
      CompatibleRuntimes:
        - python3.9
        - python3.10
        - python3.11

  MyLambdaFunction:
    Type: AWS::Serverless::Function
    Properties:
      FunctionName: MyLambdaFunction
      Runtime: python3.9
      Handler: app.handler
      CodeUri: s3://amzn-s3-demo-bucket/my-function
      Layers:
        - !Ref MyLambdaLayer
```