Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris. # Sesuaikan build dengan AWS SAM Anda dapat menyesuaikan build Anda untuk menyertakan fungsi Lambda tertentu atau lapisan Lambda. Fungsi adalah sumber daya yang dapat Anda panggil untuk menjalankan kode Anda di Lambda. Lapisan Lambda memungkinkan Anda mengekstrak kode dari fungsi Lambda yang kemudian dapat digunakan kembali di beberapa fungsi Lambda. Anda dapat memilih untuk menyesuaikan build Anda dengan fungsi Lambda tertentu ketika Anda ingin fokus pada pengembangan dan penerapan fungsi tanpa server individual tanpa kerumitan mengelola dependensi atau sumber daya bersama. Selain itu, Anda dapat memilih untuk membangun lapisan Lambda untuk membantu Anda mengurangi ukuran paket penerapan Anda, memisahkan logika fungsi inti dari dependensi, dan memungkinkan Anda untuk berbagi dependensi di beberapa fungsi. Topik di bagian ini mengeksplorasi beberapa cara berbeda yang dapat Anda gunakan untuk membangun fungsi Lambda. AWS SAM Ini termasuk membangun fungsi Lambda dengan runtime pelanggan dan membangun lapisan Lambda. Runtime kustom memungkinkan Anda menginstal dan menggunakan bahasa yang tidak tercantum dalam runtime Lambda di Panduan Pengembang. AWS Lambda Ini memungkinkan Anda membuat lingkungan eksekusi khusus untuk menjalankan fungsi dan aplikasi tanpa server. Membangun hanya lapisan Lambda (alih-alih membangun seluruh aplikasi Anda) dapat menguntungkan Anda dalam beberapa cara. Ini dapat membantu Anda mengurangi ukuran paket penerapan Anda, memisahkan logika fungsi inti dari dependensi, dan memungkinkan Anda untuk berbagi dependensi di beberapa fungsi. Untuk informasi selengkapnya tentang fungsi, lihat [Konsep Lambda](https://docs.aws.amazon.com/lambda/latest/dg/gettingstarted-concepts.html) di Panduan *AWS Lambda Pengembang*. **Topics** + [Membangun fungsi Lambda Node.js dengan esbuild di AWS SAM](serverless-sam-cli-using-build-typescript.md) + [Membangun fungsi.NET Lambda dengan kompilasi AOT Asli di AWS SAM](build-dotnet7.md) + [Membangun fungsi Lambda Karat dengan in Cargo Lambda AWS SAM](building-rust.md) + [Membangun fungsi Lambda Python dengan in uv AWS SAM](building-python-uv.md) + [Membangun fungsi Lambda dengan runtime khusus di AWS SAM](building-custom-runtimes.md) + [Membangun lapisan Lambda di AWS SAM](building-layers.md) # Membangun fungsi Lambda Node.js dengan esbuild di AWS SAM Untuk membangun dan mengemas AWS Lambda fungsi Node.js, Anda dapat menggunakan AWS SAMCLI JavaScript bundler dengan esbuild. Bundler esbuild mendukung fungsi Lambda yang Anda tulis. TypeScript Untuk membangun fungsi Lambda Node.js dengan esbuild, tambahkan `Metadata` objek ke `AWS:Serverless::Function` sumber daya Anda dan tentukan `esbuild` untuk. `BuildMethod` Saat Anda menjalankan **sam build** perintah, AWS SAM gunakan esbuild untuk menggabungkan kode fungsi Lambda Anda. ## Properti metadata `Metadata`Objek mendukung properti berikut untuk esbuild. ### BuildMethod Menentukan bundler untuk aplikasi Anda. Satu-satunya nilai yang di-support adalah `esbuild`. ### BuildProperties Menentukan properti build untuk kode fungsi Lambda Anda. `BuildProperties`Objek mendukung properti berikut untuk esbuild. Semua properti adalah opsional. Secara default, AWS SAM gunakan penangan fungsi Lambda Anda untuk titik masuk. **EntryPoints** Menentukan titik masuk untuk aplikasi Anda. **Eksternal** Menentukan daftar paket untuk menghilangkan dari build. Untuk informasi lebih lanjut, lihat [Eksternal](https://esbuild.github.io/api/#external) di *esbuildsitus web*. **Format** Menentukan format output dari JavaScript file yang dihasilkan dalam aplikasi Anda. Untuk informasi selengkapnya, lihat [Format](https://esbuild.github.io/api/#format) di *situs web esbuild*. **Loader** Menentukan daftar konfigurasi untuk memuat data untuk jenis file tertentu. **MainFields** Menentukan `package.json` bidang untuk mencoba mengimpor ketika menyelesaikan paket. Nilai default-nya adalah `main,module`. **Mengecilkan** Menentukan apakah untuk mengecilkan kode output dibundel. Nilai default-nya adalah `true`. **OutExtension** Kustomisasi ekstensi file dari file yang dihasilkan esBUILD. Untuk informasi lebih lanjut, lihat [Ekstensi keluar](https://esbuild.github.io/api/#out-extension) di *situs web esbuild*. **Peta sumber** Menentukan apakah bundler menghasilkan file peta sumber. Nilai default-nya adalah `false`. Ketika diatur ke`true`, `NODE_OPTIONS: --enable-source-maps` ditambahkan ke variabel lingkungan fungsi Lambda, dan peta sumber dihasilkan dan disertakan dalam fungsi. Atau, ketika `NODE_OPTIONS: --enable-source-maps` disertakan dalam variabel lingkungan fungsi, secara otomatis `Sourcemap` diatur ke`true`. Saat berkonflik, lebih `Sourcemap: false` diutamakan. `NODE_OPTIONS: --enable-source-maps` Secara default, Lambda mengenkripsi semua variabel lingkungan saat istirahat dengan (). AWS Key Management Service AWS KMS Saat menggunakan peta sumber, agar penerapan berhasil, peran eksekusi fungsi Anda harus memiliki izin untuk melakukan `kms:Encrypt` tindakan. **SourcesContent** Menentukan apakah akan menyertakan kode sumber Anda dalam file peta sumber Anda. Konfigurasikan properti ini saat `Sourcemap` disetel ke`'true'`. + Tentukan `SourcesContent: 'true'` untuk menyertakan semua kode sumber. + Tentukan `SourcesContent: 'false'` untuk mengecualikan semua kode sumber. Ini menghasilkan ukuran file peta sumber yang lebih kecil, yang berguna dalam produksi dengan mengurangi waktu start-up. Namun, kode sumber tidak akan tersedia di debugger. Nilai default-nya adalah `SourcesContent: true`. Untuk informasi selengkapnya, lihat [Konten sumber](https://esbuild.github.io/api/#sources-content) di *situs web esbuild*. **Target** Menentukan ECMAScript versi target. Nilai default-nya adalah `es2020`. ## TypeScript Contoh fungsi Lambda Contoh cuplikan AWS SAM template berikut menggunakan esbuild untuk membuat fungsi Lambda Node.js dari kode di. TypeScript `hello-world/app.ts` ``` Resources: HelloWorldFunction: Type: AWS::Serverless::Function Properties: CodeUri: hello-world/ Handler: app.handler Runtime: nodejs20.x Architectures: - x86_64 Events: HelloWorld: Type: Api Properties: Path: /hello Method: get Environment: Variables: NODE_OPTIONS: --enable-source-maps Metadata: BuildMethod: esbuild BuildProperties: Format: esm Minify: false OutExtension: - .js=.mjs Target: "es2020" Sourcemap: true EntryPoints: - app.ts External: - "" ``` # Membangun fungsi.NET Lambda dengan kompilasi AOT Asli di AWS SAM Bangun dan kemas AWS Lambda fungsi.NET 8 Anda dengan AWS Serverless Application Model (AWS SAM), menggunakan kompilasi Native Ahead-of-Time (AOT) untuk meningkatkan waktu mulai AWS Lambda dingin. **Topics** + [.NET 8 Ikhtisar AOT asli](#build-dotnet7-overview) + [Menggunakan AWS SAM dengan fungsi.NET 8 Lambda](#build-dotnet7-sam) + [Instal prasyarat](#build-dotnet7-prerequisites) + [Tentukan fungsi.NET 8 Lambda di template Anda AWS SAM](#build-dotnet7-sam-define) + [Membangun aplikasi Anda dengan AWS SAMCLI](#build-dotnet7-sam-build) + [Pelajari selengkapnya](#build-dotnet7-learn-more) ## .NET 8 Ikhtisar AOT asli Secara historis, fungsi.NET Lambda memiliki waktu mulai dingin yang memengaruhi pengalaman pengguna, latensi sistem, dan biaya penggunaan aplikasi tanpa server Anda. Dengan kompilasi .NET Native AOT, Anda dapat meningkatkan waktu mulai dingin dari fungsi Lambda Anda. Untuk mempelajari lebih lanjut tentang Native AOT untuk.NET 8, lihat [Menggunakan AOT Asli](https://github.com/dotnet/runtime/tree/main/src/coreclr/nativeaot#readme) di repositori * GitHub Dotnet*. ## Menggunakan AWS SAM dengan fungsi.NET 8 Lambda Lakukan hal berikut untuk mengonfigurasi fungsi.NET 8 Lambda Anda dengan AWS Serverless Application Model ()AWS SAM: + Instal prasyarat pada mesin pengembangan Anda. + Tentukan fungsi.NET 8 Lambda di template Anda AWS SAM . + Bangun aplikasi Anda dengan AWS SAMCLI. ## Instal prasyarat Berikut ini adalah prasyarat yang diperlukan: + The AWS SAMCLI + CLI INTI .NET + Alat Global Inti Amazon.Lambda.Tools .NET + Docker **Instal AWS SAMCLI** 1. Untuk memeriksa apakah Anda sudah AWS SAMCLI menginstal, jalankan yang berikut ini: ``` sam --version ``` 1. Untuk menginstal AWS SAMCLI, lihat[Instal AWS SAMCLI](install-sam-cli.md). 1. Untuk memutakhirkan versi terinstal AWS SAMCLI, lihat[Upgrade AWS SAMCLI](manage-sam-cli-versions.md#manage-sam-cli-versions-upgrade). **Instal CLI CLI.NET** 1. Untuk mengunduh dan menginstal .NET Core CLI, lihat [Mengunduh.NET](https://dotnet.microsoft.com/download) dari situs web Microsoft. 1. *Untuk informasi selengkapnya tentang.NET Core CLI, lihat [.NET Core CLI](https://docs.aws.amazon.com/lambda/latest/dg/csharp-package-cli.html) di Panduan Pengembang.AWS Lambda * **Instal Amazon.Lambda.Tools .NET Core Global Tool** 1. Jalankan perintah berikut: ``` dotnet tool install -g Amazon.Lambda.Tools ``` 1. Jika Anda sudah menginstal alat tersebut, Anda dapat memastikan alat tersebut menggunakan versi terbaru dengan perintah berikut. ``` dotnet tool update -g Amazon.Lambda.Tools ``` 1. Untuk informasi selengkapnya tentang Amazon.Lambda.Tools .NET Core Global Tool, lihat Extensions [AWS for](https://github.com/aws/aws-extensions-for-dotnet-cli) .NET CLI repositori.NET di. GitHub **Instal Docker** + Membangun dengan Native AOT, Docker harus diinstal. Untuk instruksi instalasi, lihat [Menginstal Docker untuk digunakan dengan AWS SAMCLI](install-docker.md). ## Tentukan fungsi.NET 8 Lambda di template Anda AWS SAM Untuk mendefinisikan a. NET8 Fungsi Lambda di AWS SAM template Anda, lakukan hal berikut: 1. Jalankan perintah berikut dari direktori awal pilihan Anda: ``` sam init ``` 1. Pilih `AWS Quick Start Templates` untuk memilih template awal. 1. Pilih `Hello World Example` template. 1. Pilih untuk tidak menggunakan runtime dan jenis paket paling populer dengan memasukkan`n`. 1. Untuk runtime, pilih`dotnet8`. 1. Untuk jenis paket, pilih`Zip`. 1. Untuk template pemula Anda, pilih`Hello World Example using native AOT`. **Instal Docker** + Membangun dengan Native AOT, Docker harus diinstal. Untuk instruksi instalasi, lihat [Menginstal Docker untuk digunakan dengan AWS SAMCLI](install-docker.md). ``` Resources: HelloWorldFunction: Type: AWS::Serverless::Function Properties: CodeUri: ./src/HelloWorldAot/ Handler: bootstrap Runtime: dotnet8 Architectures: - x86_64 Events: HelloWorldAot: Type: Api Properties: Path: /hello Method: get ``` **catatan** Ketika `Event` properti `AWS::Serverless::Function` diatur ke`Api`, tetapi `RestApiId` properti tidak ditentukan, AWS SAM menghasilkan `AWS::ApiGateway::RestApi` CloudFormation sumber daya. ## Membangun aplikasi Anda dengan AWS SAMCLI Dari direktori root proyek Anda, jalankan `sam build` perintah untuk mulai membangun aplikasi Anda. Jika `PublishAot` properti telah ditentukan dalam file proyek.NET 8 Anda, AWS SAMCLI akan dibangun dengan kompilasi AOT Asli. Untuk mempelajari lebih lanjut tentang `PublishAot` properti, lihat [Penerapan AOT Asli](https://learn.microsoft.com/en-us/dotnet/core/deploying/native-aot/) di dokumentasi *.NET* Microsoft. Untuk membangun fungsi Anda, AWS SAMCLI memanggil CLI CLI .NET yang menggunakan Amazon.Lambda.Tools .NET Core Global Tool. **catatan** Saat membangun, jika `.sln` file ada di direktori yang sama atau induk proyek Anda, direktori yang berisi `.sln` file akan dipasang ke wadah. Jika `.sln` file tidak ditemukan, hanya folder proyek yang dipasang. Oleh karena itu, jika Anda sedang membangun aplikasi multi-proyek, pastikan `.sln` file tersebut berada di properti. ## Pelajari selengkapnya Untuk informasi selengkapnya tentang membangun fungsi.NET 8 Lambda, lihat [Memperkenalkan runtime .NET 8](https://aws.amazon.com/blogs/compute/introducing-the-net-8-runtime-for-aws-lambda/) untuk. AWS Lambda Untuk referensi **sam build** perintah, lihat[sam build](sam-cli-command-reference-sam-build.md). # Membangun fungsi Lambda Karat dengan in Cargo Lambda AWS SAM | | | --- | | Fitur ini dalam rilis pratinjau untuk AWS SAM dan dapat berubah. | Gunakan AWS Serverless Application Model Command Line Interface (AWS SAMCLI) dengan AWS Lambda fungsi Rust Anda. **Topics** + [Prasyarat](#building-rust-prerequisites) + [Mengkonfigurasi AWS SAM untuk digunakan dengan fungsi Rust Lambda](#building-rust-configure) + [Contoh](#building-rust-examples) ## Prasyarat **Rustbahasa** Untuk menginstalRust, lihat [Menginstal Rust](https://www.rust-lang.org/tools/install) di *situs web Rust bahasa*. **Cargo Lambda** AWS SAMCLIMemerlukan instalasi [https://www.cargo-lambda.info/guide/what-is-cargo-lambda.html](https://www.cargo-lambda.info/guide/what-is-cargo-lambda.html), subperintah untukCargo. Untuk petunjuk penginstalan, lihat [Instalasi](https://www.cargo-lambda.info/guide/installation.html) dalam *Cargo Lambdadokumentasi*. **Docker** Membangun dan menguji fungsi Rust Lambda membutuhkan. Docker Untuk instruksi instalasi, lihat [Menginstal Docker](install-docker.md). **Ikut serta dalam fitur AWS SAMCLI beta** Karena fitur ini dalam pratinjau, Anda harus memilih untuk menggunakan salah satu metode berikut: 1. Gunakan variabel lingkungan:`SAM_CLI_BETA_RUST_CARGO_LAMBDA=1`. 1. Tambahkan hal berikut ke file `samconfig.toml` Anda: ``` [default.build.parameters] beta_features = true [default.sync.parameters] beta_features = true ``` 1. Gunakan `--beta-features` opsi saat menggunakan AWS SAMCLI perintah yang didukung. Contoh: ``` $ sam build --beta-features ``` 1. Pilih opsi `y` saat AWS SAMCLI meminta Anda untuk ikut serta. Berikut ini adalah contohnya: ``` $ sam build Starting Build use cache Build method "rust-cargolambda" is a beta feature. Please confirm if you would like to proceed You can also enable this beta feature with "sam build --beta-features". [y/N]: y ``` ## Mengkonfigurasi AWS SAM untuk digunakan dengan fungsi Rust Lambda ### Langkah 1: Konfigurasikan AWS SAM template Anda Konfigurasikan AWS SAM template Anda dengan yang berikut ini: + **Biner** - Opsional. Tentukan kapan template Anda berisi beberapa fungsi Rust Lambda. + **BuildMethod** – `rust-cargolambda`. + **CodeUri**— jalur ke `Cargo.toml` file Anda. + **Pawang** —`bootstrap`. + **Runtime** —`provided.al2`. Untuk mempelajari selengkapnya tentang runtime kustom, lihat [AWS Lambda Waktu proses kustom](https://docs.aws.amazon.com/lambda/latest/dg/runtimes-custom.html) di Panduan *AWS Lambda Pengembang*. Berikut adalah contoh AWS SAM template yang dikonfigurasi: ``` AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 ... Resources: MyFunction: Type: AWS::Serverless::Function Metadata: BuildMethod: rust-cargolambda BuildProperties: function_a Properties: CodeUri: ./rust_app Handler: bootstrap Runtime: provided.al2 ... ``` ### Langkah 2: Gunakan AWS SAMCLI dengan fungsi Rust Lambda Anda Gunakan AWS SAMCLI perintah apa pun dengan AWS SAM template Anda. Untuk informasi selengkapnya, lihat [AWS SAM CLI](using-sam-cli.md). ## Contoh ### Contoh Hello World **Dalam contoh ini, kita membangun contoh aplikasi Hello World menggunakan Rust sebagai runtime kita.** Pertama, kami menginisialisasi aplikasi tanpa server baru menggunakan. `sam init` Selama aliran interaktif, kami memilih **aplikasi Hello World** dan memilih runtime **Rust**. ``` $ sam init ... Which template source would you like to use? 1 - AWS Quick Start Templates 2 - Custom Template Location Choice: 1 Choose an AWS Quick Start application template 1 - Hello World Example 2 - Multi-step workflow 3 - Serverless API ... Template: 1 Use the most popular runtime and package type? (Python and zip) [y/N]: ENTER Which runtime would you like to use? 1 - dotnet8 2 - dotnet6 3 - go (provided.al2) ... 18 - python3.11 19 - python3.10 20 - ruby3.3 21 - ruby3.2 22 - rust (provided.al2) 23 - rust (provided.al2023) Runtime: 22 Based on your selections, the only Package type available is Zip. We will proceed to selecting the Package type as Zip. Based on your selections, the only dependency manager available is cargo. We will proceed copying the template using cargo. Would you like to enable X-Ray tracing on the function(s) in your application? [y/N]: ENTER Would you like to enable monitoring using CloudWatch Application Insights? For more info, please view https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/cloudwatch-application-insights.html [y/N]: ENTER Project name [sam-app]: hello-rust ----------------------- Generating application: ----------------------- Name: hello-rust Runtime: rust (provided.al2) Architectures: x86_64 Dependency Manager: cargo Application Template: hello-world Output Directory: . Configuration file: hello-rust/samconfig.toml Next steps can be found in the README file at hello-rust/README.md Commands you can use next ========================= [*] Create pipeline: cd hello-rust && sam pipeline init --bootstrap [*] Validate SAM template: cd hello-rust && sam validate [*] Test Function in the Cloud: cd hello-rust && sam sync --stack-name {stack-name} --watch ``` Berikut ini adalah struktur aplikasi Hello World kami: ``` hello-rust ├── README.md ├── events │ └── event.json ├── rust_app │ ├── Cargo.toml │ └── src │ └── main.rs ├── samconfig.toml └── template.yaml ``` Dalam AWS SAM template kami, Rust fungsi kami didefinisikan sebagai berikut: ``` AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 ... Resources: HelloWorldFunction: Type: AWS::Serverless::Function Metadata: BuildMethod: rust-cargolambda Properties: CodeUri: ./rust_app Handler: bootstrap Runtime: provided.al2 Architectures: - x86_64 Events: HelloWorld: Type: Api Path: /hello Method: get ``` Selanjutnya, kami menjalankan `sam build` untuk membangun aplikasi kami dan mempersiapkan penerapan. AWS SAMCLIMembuat `.aws-sam` direktori dan mengatur artefak build kami di sana. Fungsi kami dibangun menggunakan Cargo Lambda dan disimpan sebagai biner yang dapat dieksekusi di. `.aws-sam/build/HelloWorldFunction/bootstrap` **catatan** Jika Anda berencana menjalankan **sam local invoke** perintah di macOS, Anda perlu membangun fungsi yang berbeda sebelum menjalankan. Untuk melakukan ini, gunakan perintah berikut: **SAM\$1BUILD\$1MODE=debug sam build** Perintah ini hanya diperlukan jika pengujian lokal akan dilakukan. Ini tidak disarankan saat membangun untuk penerapan. ``` hello-rust$ sam build Starting Build use cache Build method "rust-cargolambda" is a beta feature. Please confirm if you would like to proceed You can also enable this beta feature with "sam build --beta-features". [y/N]: y Experimental features are enabled for this session. Visit the docs page to learn more about the AWS Beta terms https://aws.amazon.com/service-terms/. Cache is invalid, running build and copying resources for following functions (HelloWorldFunction) Building codeuri: /Users/.../hello-rust/rust_app runtime: provided.al2 metadata: {'BuildMethod': 'rust-cargolambda'} architecture: x86_64 functions: HelloWorldFunction Running RustCargoLambdaBuilder:CargoLambdaBuild Running RustCargoLambdaBuilder:RustCopyAndRename Build Succeeded Built Artifacts : .aws-sam/build Built Template : .aws-sam/build/template.yaml Commands you can use next ========================= [*] Validate SAM template: sam validate [*] Invoke Function: sam local invoke [*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch [*] Deploy: sam deploy --guided ``` Selanjutnya, kami menerapkan aplikasi kami menggunakan`sam deploy --guided`. ``` hello-rust$ sam deploy --guided Configuring SAM deploy ====================== Looking for config file [samconfig.toml] : Found Reading default arguments : Success Setting default arguments for 'sam deploy' ========================================= Stack Name [hello-rust]: ENTER AWS Region [us-west-2]: ENTER #Shows you resources changes to be deployed and require a 'Y' to initiate deploy Confirm changes before deploy [Y/n]: ENTER #SAM needs permission to be able to create roles to connect to the resources in your template Allow SAM CLI IAM role creation [Y/n]: ENTER #Preserves the state of previously provisioned resources when an operation fails Disable rollback [y/N]: ENTER HelloWorldFunction may not have authorization defined, Is this okay? [y/N]: y Save arguments to configuration file [Y/n]: ENTER SAM configuration file [samconfig.toml]: ENTER SAM configuration environment [default]: ENTER Looking for resources needed for deployment: ... Uploading to hello-rust/56ba6585d80577dd82a7eaaee5945c0b 817973 / 817973 (100.00%) Deploying with following values =============================== Stack name : hello-rust Region : us-west-2 Confirm changeset : True Disable rollback : False Deployment s3 bucket : aws-sam-cli-managed-default-samclisam-s3-demo-bucket-1a4x26zbcdkqr Capabilities : ["CAPABILITY_IAM"] Parameter overrides : {} Signing Profiles : {} Initiating deployment ===================== Uploading to hello-rust/a4fc54cb6ab75dd0129e4cdb564b5e89.template 1239 / 1239 (100.00%) Waiting for changeset to be created.. CloudFormation stack changeset --------------------------------------------------------------------------------------------------------- Operation LogicalResourceId ResourceType Replacement --------------------------------------------------------------------------------------------------------- + Add HelloWorldFunctionHelloW AWS::Lambda::Permission N/A orldPermissionProd ... --------------------------------------------------------------------------------------------------------- Changeset created successfully. arn:aws:cloudformation:us-west-2:012345678910:changeSet/samcli-deploy1681427201/f0ef1563-5ab6-4b07-9361-864ca3de6ad6 Previewing CloudFormation changeset before deployment ====================================================== Deploy this changeset? [y/N]: y 2023-04-13 13:07:17 - Waiting for stack create/update to complete CloudFormation events from stack operations (refresh every 5.0 seconds) --------------------------------------------------------------------------------------------------------- ResourceStatus ResourceType LogicalResourceId ResourceStatusReason --------------------------------------------------------------------------------------------------------- CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole - CREATE_IN_PROGRESS AWS::IAM::Role HelloWorldFunctionRole Resource creation ... --------------------------------------------------------------------------------------------------------- CloudFormation outputs from deployed stack --------------------------------------------------------------------------------------------------------- Outputs --------------------------------------------------------------------------------------------------------- Key HelloWorldFunctionIamRole Description Implicit IAM Role created for Hello World function Value arn:aws:iam::012345678910:role/hello-rust-HelloWorldFunctionRole-10II2P13AUDUY Key HelloWorldApi Description API Gateway endpoint URL for Prod stage for Hello World function Value https://ggdxec9le9.execute-api.us-west-2.amazonaws.com/Prod/hello/ Key HelloWorldFunction Description Hello World Lambda Function ARN Value arn:aws:lambda:us-west-2:012345678910:function:hello-rust-HelloWorldFunction- yk4HzGzYeZBj --------------------------------------------------------------------------------------------------------- Successfully created/updated stack - hello-rust in us-west-2 ``` Untuk menguji, kita dapat memanggil fungsi Lambda kita menggunakan titik akhir API. ``` $ curl https://ggdxec9le9.execute-api.us-west-2.amazonaws.com/Prod/hello/ Hello World!% ``` Untuk menguji fungsi kami secara lokal, pertama-tama kami memastikan `Architectures` properti fungsi kami cocok dengan mesin lokal kami. ``` ... Resources: HelloWorldFunction: Type: AWS::Serverless::Function # More info about Function Resource: https://github.com/awslabs/serverless-application-model/blob/master/versions/2016-10-31.md#awsserverlessfunction Metadata: BuildMethod: rust-cargolambda # More info about Cargo Lambda: https://github.com/cargo-lambda/cargo-lambda Properties: CodeUri: ./rust_app # Points to dir of Cargo.toml Handler: bootstrap # Do not change, as this is the default executable name produced by Cargo Lambda Runtime: provided.al2 Architectures: - arm64 ... ``` Karena kami memodifikasi arsitektur kami dari `x86_64` ke `arm64` dalam contoh ini, kami menjalankan `sam build` untuk memperbarui artefak build kami. Kami kemudian menjalankan `sam local invoke` untuk memanggil fungsi kami secara lokal. ``` hello-rust$ sam local invoke Invoking bootstrap (provided.al2) Local image was not found. Removing rapid images for repo public.ecr.aws/sam/emulation-provided.al2 Building image..................................................................................................................................... Using local image: public.ecr.aws/lambda/provided:al2-rapid-arm64. Mounting /Users/.../hello-rust/.aws-sam/build/HelloWorldFunction as /var/task:ro,delegated, inside runtime container START RequestId: fbc55e6e-0068-45f9-9f01-8e2276597fc6 Version: $LATEST {"statusCode":200,"body":"Hello World!"}END RequestId: fbc55e6e-0068-45f9-9f01-8e2276597fc6 REPORT RequestId: fbc55e6e-0068-45f9-9f01-8e2276597fc6 Init Duration: 0.68 ms Duration: 130.63 ms Billed Duration: 131 ms Memory Size: 128 MB Max Memory Used: 128 MB ``` ### Proyek fungsi Lambda Tunggal **Berikut adalah contoh aplikasi tanpa server yang berisi satu fungsi Rust Lambda.** Struktur direktori proyek: ``` . ├── Cargo.lock ├── Cargo.toml ├── src │ └── main.rs └── template.yaml ``` AWS SAM Template: ``` AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 ... Resources: MyFunction: Type: AWS::Serverless::Function Metadata: BuildMethod: rust-cargolambda Properties: CodeUri: ./ Handler: bootstrap Runtime: provided.al2 ... ``` ### Beberapa proyek fungsi Lambda **Berikut adalah contoh aplikasi tanpa server yang berisi beberapa fungsi Rust Lambda.** Struktur direktori proyek: ``` . ├── Cargo.lock ├── Cargo.toml ├── src │ ├── function_a.rs │ └── function_b.rs └── template.yaml ``` AWS SAM Template: ``` AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 ... Resources: FunctionA: Type: AWS::Serverless::Function Metadata: BuildMethod: rust-cargolambda BuildProperties: Binary: function_a Properties: CodeUri: ./ Handler: bootstrap Runtime: provided.al2 FunctionB: Type: AWS::Serverless::Function Metadata: BuildMethod: rust-cargolambda BuildProperties: Binary: function_b Properties: CodeUri: ./ Handler: bootstrap Runtime: provided.al2 ``` `Cargo.toml`berkas: ``` [package] name = "test-handler" version = "0.1.0" edition = "2021" [dependencies] lambda_runtime = "0.6.0" serde = "1.0.136" tokio = { version = "1", features = ["macros"] } tracing = { version = "0.1", features = ["log"] } tracing-subscriber = { version = "0.3", default-features = false, features = ["fmt"] } [[bin]] name = "function_a" path = "src/function_a.rs" [[bin]] name = "function_b" path = "src/function_b.rs" ``` # Membangun fungsi Lambda Python dengan in uv AWS SAM | | | --- | | Fitur ini dalam rilis pratinjau untuk AWS SAM dan dapat berubah. | Gunakan AWS Serverless Application Model Command Line Interface (AWS SAMCLI) denganuv, installer dan resolver paket Python cepat, untuk membangun fungsi Python Anda. AWS Lambda **Topics** + [Prasyarat](#building-python-uv-prerequisites) + [Mengkonfigurasi AWS SAM untuk digunakan dengan fungsi Python Lambda dan uv](#building-python-uv-configure) + [Contoh](#building-python-uv-examples) ## Prasyarat **Python** *Untuk menginstal Python, lihat Unduh [Python di situs web Python](https://www.python.org/downloads/).* **uv** AWS SAMCLIMemerlukan instalasi [https://docs.astral.sh/uv/](https://docs.astral.sh/uv/), penginstal dan resolver paket Python yang sangat cepat. Untuk petunjuk penginstalan, lihat [Instalasi](https://docs.astral.sh/uv/getting-started/installation/) dalam *uvdokumentasi*. **Ikut serta dalam fitur AWS SAMCLI beta** Karena fitur ini dalam pratinjau, Anda harus memilih untuk menggunakan salah satu metode berikut: 1. Gunakan variabel lingkungan:`SAM_CLI_BETA_PYTHON_UV=1`. 1. Tambahkan hal berikut ke file `samconfig.toml` Anda: ``` [default.build.parameters] beta_features = true [default.sync.parameters] beta_features = true ``` 1. Gunakan `--beta-features` opsi saat menggunakan AWS SAMCLI perintah yang didukung. Contoh: ``` $ sam build --beta-features ``` 1. Pilih opsi `y` saat AWS SAMCLI meminta Anda untuk ikut serta. Berikut ini adalah contohnya: ``` $ sam build Starting Build use cache Build method "python-uv" is a beta feature. Please confirm if you would like to proceed You can also enable this beta feature with "sam build --beta-features". [y/N]: y ``` ## Mengkonfigurasi AWS SAM untuk digunakan dengan fungsi Python Lambda dan uv ### Langkah 1: Konfigurasikan AWS SAM template Anda Konfigurasikan AWS SAM template Anda dengan yang berikut ini: + **BuildMethod** – `python-uv`. + **CodeUri**— jalur ke direktori kode fungsi Anda yang berisi `pyproject.toml` atau`requirements.txt`. + **Handler** — handler fungsi Anda (misalnya,`app.lambda_handler`). + **Runtime** - Versi runtime Python (misalnya,). `python3.12` Berikut adalah contoh AWS SAM template yang dikonfigurasi: ``` AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 ... Resources: MyFunction: Type: AWS::Serverless::Function Properties: CodeUri: ./my_function Handler: app.lambda_handler Runtime: python3.12 Metadata: BuildMethod: python-uv ... ``` ## Contoh ### Contoh Hello World **Dalam contoh ini, kita membangun contoh aplikasi Hello World menggunakan Python dengan uv sebagai manajer paket.** uvdapat menggunakan salah satu `pyproject.toml` atau `requirements.txt` untuk membaca dependensi. Jika keduanya diberikan, `sam build` akan dibaca dari `requirements.txt` untuk dependensi. Berikut ini adalah struktur aplikasi Hello World kami: ``` hello-python-uv ├── README.md ├── events │ └── event.json ├── hello_world │ ├── __init__.py │ ├── app.py │ └── pyproject.toml ├── samconfig.toml └── template.yaml ``` `pyproject.toml`berkas: ``` [project] name = "my-function" version = "0.1.0" requires-python = ">=3.12" dependencies = [ "requests>=2.31.0", "boto3>=1.28.0", ] ``` Dalam AWS SAM template kami, fungsi Python kami didefinisikan sebagai berikut: ``` AWSTemplateFormatVersion: '2010-09-09' Transform: AWS::Serverless-2016-10-31 ... Resources: HelloWorldFunction: Type: AWS::Serverless::Function Properties: CodeUri: hello_world/ Handler: app.lambda_handler Runtime: python3.12 Architectures: - x86_64 Metadata: BuildMethod: python-uv ``` Selanjutnya, kami menjalankan `sam build` untuk membangun aplikasi kami dan mempersiapkan penerapan. AWS SAMCLIMembuat `.aws-sam` direktori dan mengatur artefak build kami di sana. Dependensi fungsi kami diinstal menggunakan uv dan disimpan di. `.aws-sam/build/HelloWorldFunction/` ``` hello-python-uv$ sam build Starting Build use cache Build method "python-uv" is a beta feature. Please confirm if you would like to proceed You can also enable this beta feature with "sam build --beta-features". [y/N]: y Experimental features are enabled for this session. Visit the docs page to learn more about the AWS Beta terms https://aws.amazon.com/service-terms/. Cache is invalid, running build and copying resources for following functions (HelloWorldFunction) Building codeuri: /Users/.../hello-python-uv/hello_world runtime: python3.12 metadata: {'BuildMethod': 'python-uv'} architecture: x86_64 functions: HelloWorldFunction Running PythonUvBuilder:UvBuild Running PythonUvBuilder:CopySource Build Succeeded Built Artifacts : .aws-sam/build Built Template : .aws-sam/build/template.yaml Commands you can use next ========================= [*] Validate SAM template: sam validate [*] Invoke Function: sam local invoke [*] Test Function in the Cloud: sam sync --stack-name {{stack-name}} --watch [*] Deploy: sam deploy --guided ``` **catatan** Metode `python-uv` build dikonfigurasi per fungsi di `Metadata` bagian. Setiap fungsi dalam template Anda dapat menggunakan metode build yang berbeda, memungkinkan Anda untuk mencampur fungsi uv berbasis dengan fungsi `pip` berbasis dalam AWS SAM template yang sama. Jika tidak ada metode build yang `pip` ditentukan, digunakan secara default. # Membangun fungsi Lambda dengan runtime khusus di AWS SAM Anda dapat menggunakan perintah `sam build` untuk membangun waktu aktif kustom yang diperlukan untuk fungsi Lambda Anda. Anda menyatakan fungsi Lambda untuk menggunakan waktu aktif kustom dengan menentukan `Runtime: provided` pada fungsi terebut. Untuk membangun waktu aktif kustom, nyatakan atribut sumber daya `Metadata` dengan entri `BuildMethod: makefile`. Anda menyediakan makefile kustom, tempat Anda menyatakan target bangunan formulir `build-function-logical-id` yang mencakup perintah pembangunan untuk waktu aktif Anda. Makefile Anda bertanggung jawab untuk menyusun waktu aktif kustom jika diperlukan, dan menyalin artefak bangunan ke lokasi yang tepat yang diperlukan untuk langkah-langkah berikutnya dalam alur kerja Anda. Lokasi makefile ditentukan oleh properti `CodeUri` dari sumber daya fungsi dan harus bernama `Makefile`. ## Contoh ### Contoh 1: Waktu aktif kustom untuk fungsi yang ditulis dalam Rust **catatan** Kami merekomendasikan membangun fungsi Lambda dengan. Cargo Lambda Untuk mempelajari selengkapnya, lihat [Membangun fungsi Lambda Karat dengan in Cargo Lambda AWS SAM](building-rust.md). AWS SAM Template berikut mendeklarasikan fungsi yang menggunakan runtime kustom untuk fungsi Lambda yang ditulis dalam Rust, dan menginstruksikan `sam build` untuk menjalankan perintah untuk target build. `build-HelloRustFunction` ``` Resources: HelloRustFunction: Type: AWS::Serverless::Function Properties: FunctionName: HelloRust Handler: bootstrap.is.real.handler Runtime: provided MemorySize: 512 CodeUri: . Metadata: BuildMethod: makefile ``` Makefile berikut berisi target bangunan dan perintah yang akan dieksekusi. Perhatikan bahwa properti `CodeUri` diatur ke `.`, maka makefile harus terletak di direktori root proyek (yaitu, direktori yang sama dengan file templat AWS SAM aplikasi). Nama file tersebut harus `Makefile`. ``` build-HelloRustFunction: cargo build --release --target x86_64-unknown-linux-musl cp ./target/x86_64-unknown-linux-musl/release/bootstrap $(ARTIFACTS_DIR) ``` Untuk informasi selengkapnya tentang pengaturan lingkungan pengembangan Anda agar dapat mengeksekusi perintah `cargo build` di `makefile` sebelumnya, lihat postingan blog [Waktu aktif Rust untuk AWS Lambda](https://aws.amazon.com/blogs/opensource/rust-runtime-for-aws-lambda/). ### Contoh 2: Pembuat makefile untuk Python3.12 (alternatif untuk menggunakan pembuat yang dibundel) Anda mungkin ingin menggunakan pustaka atau modul yang tidak disertakan dalam pembangun yang dipaketkan bersama. Contoh ini menunjukkan AWS SAM template untuk runtime Python3.12 dengan pembuat makefile. ``` Resources: HelloWorldFunction: Type: AWS::Serverless::Function Properties: CodeUri: hello_world/ Handler: app.lambda_handler Runtime: python3.12 Metadata: BuildMethod: makefile ``` Makefile berikut berisi target bangunan dan perintah yang akan dieksekusi. Perhatikan bahwa properti `CodeUri` diatur ke `hello_world`, sehingga makefile harus terletak di root subdirektori `hello_world`, dan nama file harus `Makefile`. ``` build-HelloWorldFunction: cp *.py $(ARTIFACTS_DIR) cp requirements.txt $(ARTIFACTS_DIR) python -m pip install -r requirements.txt -t $(ARTIFACTS_DIR) rm -rf $(ARTIFACTS_DIR)/bin ``` # Membangun lapisan Lambda di AWS SAM Anda dapat menggunakan AWS SAM untuk membangun lapisan Lambda kustom. Lapisan Lambda memungkinkan Anda mengekstrak kode dari fungsi Lambda yang kemudian dapat digunakan kembali di beberapa fungsi Lambda. Membangun hanya lapisan Lambda (alih-alih membangun seluruh aplikasi Anda) dapat menguntungkan Anda dalam beberapa cara. Ini dapat membantu Anda mengurangi ukuran paket penerapan Anda, memisahkan logika fungsi inti dari dependensi, dan memungkinkan Anda untuk berbagi dependensi di beberapa fungsi. Untuk informasi tentang lapisan, lihat [Lapisan Lambda AWS](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html) di *Panduan Developer AWS Lambda *. ## Cara membangun lapisan Lambda di AWS SAM **catatan** Sebelum Anda dapat membangun layer Lambda, Anda harus terlebih dahulu menulis layer Lambda di template Anda. AWS SAM Untuk informasi dan contoh tentang melakukan ini, lihat[Tingkatkan efisiensi menggunakan lapisan Lambda dengan AWS SAM](serverless-sam-cli-layers.md). Untuk membangun lapisan kustom, deklarasikan dalam file template AWS Serverless Application Model (AWS SAM) Anda dan sertakan bagian atribut `Metadata` resource dengan entri. `BuildMethod` Nilai yang valid untuk `BuildMethod` adalah pengidentifikasi pada [waktu aktif AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html), atau `makefile`. Sertakan `BuildArchitecture` entri untuk menentukan arsitektur set instruksi yang didukung lapisan Anda. Nilai yang valid untuk `BuildArchitecture` adalah arsitektur [set instruksi Lambda](https://docs.aws.amazon.com/lambda/latest/dg/foundation-arch.html). Jika Anda menentukan `makefile`, sediakan makefile kustom, tempat Anda menyatakan target bangunan formulir `build-layer-logical-id` yang berisi perintah pembangunan untuk lapisan Anda. Makefile Anda bertanggung jawab untuk menyusun lapisan jika diperlukan, dan menyalin artefak bangunan ke lokasi yang tepat yang diperlukan untuk langkah-langkah berikutnya dalam alur kerja Anda. Lokasi makefile ditentukan oleh properti `ContentUri` dari sumber daya lapisan dan harus diberi nama `Makefile`. **catatan** Ketika Anda membuat lapisan kustom, AWS Lambda tergantung pada variabel lingkungan untuk menemukan kode lapisan Anda. Waktu aktif Lambda termasuk jalur di direktori `/opt` tempat kode lapisan Anda disalin. Struktur folder artefak bangunan Anda harus sesuai dengan struktur folder yang diharapkan waktu aktif sehingga kode lapisan kustom Anda dapat ditemukan. Contohnya, untuk Python, Anda dapat menempatkan kode di subdirektori `python/`. Untuk NodeJS, Anda dapat menempatkan kode Anda di subdirektori `nodejs/node_modules/`. Untuk informasi selengkapnya, lihat [Menyertakan dependensi pustaka dalam lapisan](https://docs.aws.amazon.com/lambda/latest/dg/configuration-layers.html#configuration-layers-path) di *Panduan Developer AWS Lambda *. Berikut ini adalah contoh bagian atribut sumber daya `Metadata`. ``` Metadata: BuildMethod: python3.12 BuildArchitecture: arm64 ``` **catatan** Jika Anda tidak menyertakan bagian atribut `Metadata` sumber daya, AWS SAM tidak membangun lapisan. Sebaliknya, artefak bangunan akan disalin dari lokasi yang ditentukan dalam properti `CodeUri` sumber daya lapisan. Untuk informasi selengkapnya, lihat properti [ContentUri](sam-resource-layerversion.md#sam-layerversion-contenturi) tipe sumber daya `AWS::Serverless::LayerVersion`. Ketika Anda menyertakan bagian atribut `Metadata` sumber daya, Anda dapat menggunakan `sam build` perintah untuk membangun lapisan, baik sebagai objek independen, atau sebagai ketergantungan AWS Lambda fungsi. + ****Sebagai objek independen.**** Anda mungkin hanya ingin membangun objek lapisan, misalnya ketika Anda sedang menguji perubahan kode secara lokal pada lapisan dan tidak perlu membangun seluruh aplikasi Anda. Untuk membangun lapisan secara independen, tentukan sumber daya lapisan dengan perintah `sam build layer-logical-id`. + **Sebagai ketergantungan fungsi Lambda.** Bila Anda menyertakan ID logis lapisan di properti `Layers` dari fungsi Lambda di file templat AWS SAM yang sama, lapisan merupakan dependensi dari fungsi Lambda tersebut. Ketika lapisan tersebut juga menyertakan bagian atribut sumber daya `Metadata` dengan entri `BuildMethod`, Anda membangun lapisan baik dengan membangun seluruh aplikasi menggunakan perintah `sam build` atau dengan menentukan sumber daya fungsi menggunakan perintah `sam build function-logical-id`. ## Contoh ### Contoh template 1: Bangun layer terhadap lingkungan runtime Python 3.12 Contoh AWS SAM template berikut membangun lapisan terhadap lingkungan runtime Python 3.12. ``` Resources: MyLayer: Type: AWS::Serverless::LayerVersion Properties: ContentUri: my_layer CompatibleRuntimes: - python3.12 Metadata: BuildMethod: python3.12 # Required to have AWS SAM build this layer ``` ### Contoh templat 2: Bangun lapisan menggunakan makefile kustom Contoh AWS SAM template berikut menggunakan custom `makefile` untuk membangun layer. ``` Resources: MyLayer: Type: AWS::Serverless::LayerVersion Properties: ContentUri: my_layer CompatibleRuntimes: - python3.12 Metadata: BuildMethod: makefile ``` Hal `makefile` berikut berisi target build dan perintah yang akan dieksekusi. Perhatikan bahwa properti `ContentUri` diatur ke `my_layer`, sehingga makefile harus terletak di root subdirektori `my_layer`, dan nama file harus `Makefile`. Perhatikan juga bahwa artefak build disalin ke `python/` subdirektori sehingga AWS Lambda akan dapat menemukan kode layer. ``` build-MyLayer: mkdir -p "$(ARTIFACTS_DIR)/python" cp *.py "$(ARTIFACTS_DIR)/python" python -m pip install -r requirements.txt -t "$(ARTIFACTS_DIR)/python" ``` **catatan** Ketika `makefile` dipanggil, target yang sesuai dipicu dan artefak harus disalin ke variabel lingkungan yang terbuka. `$ARTIFACTS_DIR` Untuk informasi lebih lanjut, lihat [aws-lambda-builders di GitHub](https://github.com/aws/aws-lambda-builders/blob/develop/aws_lambda_builders/workflows/custom_make/DESIGN.md). ### Contoh perintah pembangunan sam Perintah `sam build` berikut ini membangun lapisan yang mencakup bagian atribut sumber daya `Metadata`. ``` # Build the 'layer-logical-id' resource independently $ sam build layer-logical-id # Build the 'function-logical-id' resource and layers that this function depends on $ sam build function-logical-id # Build the entire application, including the layers that any function depends on $ sam build ```