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

# Tutorial: Menyebarkan fungsi Lambda yang diperbarui CodeDeploy dengan dan Model Aplikasi Tanpa AWS Server
<a name="tutorial-lambda-sam"></a>

AWS SAM adalah kerangka kerja sumber terbuka untuk membangun aplikasi tanpa server. Ini mengubah dan memperluas sintaks YAMAL dalam AWS SAM template menjadi CloudFormation sintaks untuk membangun aplikasi tanpa server, seperti fungsi Lambda. Untuk informasi selengkapnya, lihat [Apa itu AWS Model Aplikasi Tanpa Server](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html)? 

 Dalam tutorial ini, Anda menggunakan AWS SAM untuk membuat solusi yang melakukan hal berikut: 
+  Membuat fungsi Lambda Anda. 
+  Membuat grup CodeDeploy aplikasi dan penyebaran Anda. 
+  Membuat dua fungsi Lambda yang menjalankan tes validasi penerapan selama kait siklus hidup. CodeDeploy 
+  Mendeteksi kapan fungsi Lambda Anda diperbarui. Pembaruan fungsi Lambda memicu penerapan yang secara bertahap menggeser lalu lintas produksi dari versi asli fungsi Lambda Anda ke versi terbaru. CodeDeploy 

**catatan**  
Tutorial ini mengharuskan Anda untuk membuat sumber daya yang mungkin menimbulkan biaya untuk akun AWS Anda. Ini termasuk kemungkinan biaya untuk CodeDeploy, Amazon CloudWatch, dan AWS Lambda. Untuk informasi selengkapnya, lihat [CodeDeploy harga](https://aws.amazon.com/codedeploy/pricing/), [ CloudWatch harga Amazon](https://aws.amazon.com/cloudwatch/pricing/), dan [AWS Lambda harga](https://aws.amazon.com/lambda/pricing/).

**Topics**
+ [Prasyarat](tutorial-lambda-sam-prereqs.md)
+ [Langkah 1: Siapkan infrastruktur Anda](tutorial-lambda-sam-setup-infrastructure.md)
+ [Langkah 2: Perbarui fungsi Lambda](tutorial-lambda-sam-update-function.md)
+ [Langkah 3: Menyebarkan fungsi Lambda yang diperbarui](tutorial-lambda-sam-deploy-update.md)
+ [Langkah 4: Lihat hasil penerapan Anda](tutorial-lambda-sam-deploy-view-results.md)
+ [Langkah 5: Bersihkan](tutorial-lambda-clean-up.md)

# Prasyarat
<a name="tutorial-lambda-sam-prereqs"></a>

Untuk menyelesaikan tutorial ini, Anda harus terlebih dahulu:
+  Selesaikan langkah-langkah dalam [Memulai dengan CodeDeploy](getting-started-codedeploy.md). 
+  Instal AWS Serverless Application Model CLI. Untuk selengkapnya, lihat [Menginstal AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html). 
+  Buat ember S3. AWS SAM mengunggah artefak yang direferensikan dalam [template AWS SAM](https://docs.aws.amazon.com/en_us/codedeploy/latest/userguide/tutorial-lambda-sam-template.html) Anda ke dalam ember ini. 

# Langkah 1: Siapkan infrastruktur Anda
<a name="tutorial-lambda-sam-setup-infrastructure"></a>

 Topik ini menunjukkan cara menggunakan AWS SAM untuk membuat file untuk AWS SAM template dan fungsi Lambda Anda. Kemudian, Anda menggunakan `deploy` perintah AWS SAM `package` dan untuk menghasilkan komponen dalam infrastruktur Anda. Ketika infrastruktur sudah siap, Anda memiliki grup CodeDeploy aplikasi dan penyebaran, fungsi Lambda untuk memperbarui dan menyebarkan, dan dua fungsi Lambda yang berisi pengujian validasi yang berjalan saat Anda menerapkan fungsi Lambda. Setelah selesai, Anda dapat menggunakan CloudFormation untuk melihat komponen Anda di konsol Lambda atau AWS CLI untuk menguji fungsi Lambda Anda. 

**Topics**
+ [Buat file Anda](tutorial-lambda-create-files.md)
+ [Package aplikasi AWS SAM](tutorial-lambda-sam-package.md)
+ [Menyebarkan aplikasi AWS SAM](tutorial-lambda-sam-deploy.md)
+ [(Opsional) memeriksa dan menguji infrastruktur Anda](tutorial-lambda-sam-confirm-components.md)

# Buat file Anda
<a name="tutorial-lambda-create-files"></a>

 Untuk membuat infrastruktur Anda, Anda harus membuat file-file berikut: 
+ `template.yml`
+ `myDateTimeFunction.js`
+ `beforeAllowTraffic.js`
+ `afterAllowTraffic.js`

**Topics**
+ [Buat template AWS SAM Anda](tutorial-lambda-sam-template.md)
+ [Buat file untuk fungsi Lambda Anda](tutorial-lambda-sam-create-lambda-function.md)
+ [Buat file untuk fungsi BeforeAllowTraffic Lambda Anda](tutorial-lambda-sam-create-lambda-before-traffic.md)
+ [Buat file untuk fungsi AfterAllowTraffic Lambda Anda](tutorial-lambda-sam-create-lambda-after-traffic.md)

# Buat template AWS SAM Anda
<a name="tutorial-lambda-sam-template"></a>

Buat file template AWS SAM yang menentukan komponen dalam infrastruktur Anda.

**Untuk membuat template AWS SAM Anda**

1.  Membuat sebuah direktori bernama `SAM-Tutorial`. 

1.  Di `SAM-Tutorial` direktori Anda, buat file bernama`template.yml`. 

1.  Salin kode YAML berikut ke dalam`template.yml`. Ini adalah AWS SAM template Anda. 

   ```
   AWSTemplateFormatVersion : '2010-09-09'
   Transform: AWS::Serverless-2016-10-31
   Description: A sample SAM template for deploying Lambda functions.
   
   Resources:
   # Details about the myDateTimeFunction Lambda function
     myDateTimeFunction:
       Type: AWS::Serverless::Function
       Properties:
         Handler: myDateTimeFunction.handler
         Runtime: nodejs18.x
   # Instructs your myDateTimeFunction is published to an alias named "live".      
         AutoPublishAlias: live
   # Grants this function permission to call lambda:InvokeFunction
         Policies:
           - Version: "2012-10-17"		 	 	 
             Statement: 
             - Effect: "Allow"
               Action: 
                 - "lambda:InvokeFunction"
               Resource: '*'
         DeploymentPreference:
   # Specifies the deployment configuration      
             Type: Linear10PercentEvery1Minute
   # Specifies Lambda functions for deployment lifecycle hooks
             Hooks:
               PreTraffic: !Ref beforeAllowTraffic
               PostTraffic: !Ref afterAllowTraffic
               
   # Specifies the BeforeAllowTraffic lifecycle hook Lambda function
     beforeAllowTraffic:
       Type: AWS::Serverless::Function
       Properties:
         Handler: beforeAllowTraffic.handler
         Policies:
           - Version: "2012-10-17"		 	 	 
   # Grants this function permission to call codedeploy:PutLifecycleEventHookExecutionStatus        
             Statement: 
             - Effect: "Allow"
               Action: 
                 - "codedeploy:PutLifecycleEventHookExecutionStatus"
               Resource:
                 !Sub 'arn:aws:codedeploy:${AWS::Region}:${AWS::AccountId}:deploymentgroup:${ServerlessDeploymentApplication}/*'
           - Version: "2012-10-17"		 	 	 
   # Grants this function permission to call lambda:InvokeFunction        
             Statement: 
             - Effect: "Allow"
               Action: 
                 - "lambda:InvokeFunction"
               Resource: !Ref myDateTimeFunction.Version
         Runtime: nodejs18.x
   # Specifies the name of the Lambda hook function      
         FunctionName: 'CodeDeployHook_beforeAllowTraffic'
         DeploymentPreference:
           Enabled: false
         Timeout: 5
         Environment:
           Variables:
             NewVersion: !Ref myDateTimeFunction.Version
             
   # Specifies the AfterAllowTraffic lifecycle hook Lambda function
     afterAllowTraffic:
       Type: AWS::Serverless::Function
       Properties:
         Handler: afterAllowTraffic.handler
         Policies:
           - Version: "2012-10-17"		 	 	 
             Statement: 
   # Grants this function permission to call codedeploy:PutLifecycleEventHookExecutionStatus         
             - Effect: "Allow"
               Action: 
                 - "codedeploy:PutLifecycleEventHookExecutionStatus"
               Resource:
                 !Sub 'arn:aws:codedeploy:${AWS::Region}:${AWS::AccountId}:deploymentgroup:${ServerlessDeploymentApplication}/*'
           - Version: "2012-10-17"		 	 	 
             Statement: 
   # Grants this function permission to call lambda:InvokeFunction          
             - Effect: "Allow"
               Action: 
                 - "lambda:InvokeFunction"
               Resource: !Ref myDateTimeFunction.Version
         Runtime: nodejs18.x
   # Specifies the name of the Lambda hook function      
         FunctionName: 'CodeDeployHook_afterAllowTraffic'
         DeploymentPreference:
           Enabled: false
         Timeout: 5
         Environment:
           Variables:
             NewVersion: !Ref myDateTimeFunction.Version
   ```

Template ini menentukan berikut ini. Untuk informasi selengkapnya, lihat [konsep AWS SAM templat](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-basics.html).

**Fungsi Lambda disebut `myDateTimeFunction`**  
 Ketika fungsi Lambda ini diterbitkan, `AutoPublishAlias` baris dalam template menautkannya ke alias bernama. `live` Kemudian dalam tutorial ini, pembaruan untuk fungsi ini memicu penerapan yang secara bertahap menggeser lalu lintas produksi dari versi asli ke versi yang diperbarui. AWS CodeDeploy 

**Dua fungsi validasi penerapan Lambda**  
 Fungsi Lambda berikut dijalankan selama kait siklus CodeDeploy hidup. Fungsi berisi kode yang memvalidasi penyebaran yang diperbarui. `myDateTimeFunction` Hasil tes validasi diteruskan CodeDeploy menggunakan metode `PutLifecycleEventHookExecutionStatus` API-nya. Jika tes validasi gagal, penerapan gagal dan dibatalkan.   
+  `CodeDeployHook_beforeAllowTraffic`berjalan selama `BeforeAllowTraffic` pengait. 
+  `CodeDeployHook_afterAllowTraffic`berjalan selama `AfterAllowTraffic` pengait. 
Nama kedua fungsi dimulai dengan`CodeDeployHook_`. `CodeDeployRoleForLambda`Peran memungkinkan panggilan ke `invoke` metode Lambda hanya dalam fungsi Lambda dengan nama yang dimulai dengan awalan ini. Untuk informasi selengkapnya, lihat [AppSpec Bagian 'kait' untuk penerapan AWS Lambda](reference-appspec-file-structure-hooks.md#appspec-hooks-lambda) dan [PutLifecycleEventHookExecutionStatus](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_PutLifecycleEventHookExecutionStatus.html)di *Referensi CodeDeploy API*. 

**Deteksi otomatis fungsi Lambda yang diperbarui**  
 `AutoPublishAlias`Istilah ini memberi tahu kerangka kerja untuk mendeteksi kapan `myDateTimeFunction` fungsi berubah, dan kemudian menerapkannya menggunakan `live` alias. 

**Konfigurasi penerapan**  
 Konfigurasi deployment menentukan tingkat di mana CodeDeploy aplikasi Anda mengalihkan lalu lintas dari versi asli fungsi Lambda ke versi baru. Template ini menentukan konfigurasi deployment yang telah ditetapkan. `Linear10PercentEvery1Minute`   
 Anda tidak dapat menentukan konfigurasi penerapan kustom dalam template AWS SAM. Untuk informasi selengkapnya, lihat [Buat konfigurasi penerapan dengan CodeDeploy](deployment-configurations-create.md).

**Fungsi kait siklus hidup penerapan**  
 `Hooks`Bagian ini menentukan fungsi yang akan dijalankan selama kait peristiwa siklus hidup. `PreTraffic`menentukan fungsi yang berjalan selama `BeforeAllowTraffic` hook. `PostTraffic`menentukan fungsi yang berjalan selama `AfterAllowTraffic` hook. 

**Izin untuk Lambda untuk memanggil fungsi Lambda lain**  
 `lambda:InvokeFunction`Izin yang ditentukan memberikan peran yang digunakan oleh izin aplikasi AWS SAM untuk memanggil fungsi Lambda. Ini diperlukan saat `CodeDeployHook_afterAllowTraffic` fungsi `CodeDeployHook_beforeAllowTraffic` and memanggil fungsi Lambda yang diterapkan selama pengujian validasi. 

# Buat file untuk fungsi Lambda Anda
<a name="tutorial-lambda-sam-create-lambda-function"></a>

Buat file untuk fungsi yang Anda perbarui dan terapkan nanti dalam tutorial ini.

**catatan**  
 Fungsi Lambda dapat menggunakan runtime apa pun yang didukung oleh. AWS Lambda Untuk informasi selengkapnya, lihat [runtime AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html). 

**Untuk membuat fungsi Lambda Anda**

1.  Buat file teks dan simpan seperti `myDateTimeFunction.js` di `SAM-Tutorial` direktori. 

1.  Salin kode Node.js berikut ke dalam`myDateTimeFunction.js`. 

   

   ```
   'use strict';
       
       exports.handler = function(event, context, callback) {
       
         if (event.body) {
           event = JSON.parse(event.body);
         }
       
         var sc; // Status code
         var result = ""; // Response payload
       
         switch(event.option) {
           case "date": 
             switch(event.period) {
               case "yesterday":
                 result = setDateResult("yesterday");
                 sc = 200;
                 break;
               case "today":
                 result = setDateResult();
                 sc = 200;
                 break;
               case "tomorrow":
                 result = setDateResult("tomorrow");
                 sc = 200;
                 break;
               default:
                 result = {
                   "error": "Must specify 'yesterday', 'today', or 'tomorrow'."
                 };
                 sc = 400;
                 break;
             }
             break;
             
       /*      Later in this tutorial, you update this function by uncommenting 
               this section. The framework created by AWS SAM detects the update 
               and triggers a deployment by CodeDeploy. The deployment shifts 
               production traffic to the updated version of this function.
               
               case "time":
               var d = new Date();
               var h = d.getHours();
               var mi = d.getMinutes();
               var s = d.getSeconds();
       
               result = {
                 "hour": h,
                 "minute": mi,
                 "second": s
               };
               sc = 200;
               break;
       */
             default:
               result = {
                 "error": "Must specify 'date' or 'time'."
               };
               sc = 400;
             break;
         }
       
         const response = {
           statusCode: sc,
           headers: { "Content-type": "application/json" },
           body: JSON.stringify( result )
         };
       
         callback(null, response);
       
         function setDateResult(option) {
       
           var d = new Date(); // Today
           var mo; // Month
           var da; // Day
           var y; // Year
       
           switch(option) {
             case "yesterday":
               d.setDate(d.getDate() - 1);
               break;
             case "tomorrow":
               d.setDate(d.getDate() + 1);
             default:
              break;
           }
       
           mo = d.getMonth() + 1; // Months are zero offset (0-11)
           da = d.getDate();
           y = d.getFullYear();
       
           result = {
             "month": mo,
             "day": da,
             "year": y
           };
       
           return result;
         }
       };
   ```

Fungsi Lambda mengembalikan hari, bulan, dan tahun untuk kemarin, hari ini, atau besok. Kemudian dalam tutorial ini, Anda menghapus kode komentar yang memperbarui fungsi untuk mengembalikan informasi tentang hari atau waktu yang Anda tentukan (misalnya, hari, bulan, dan tahun, atau jam, menit, dan detik saat ini). Kerangka kerja yang dibuat oleh AWS SAM mendeteksi dan menyebarkan versi fungsi yang diperbarui. 

**catatan**  
 Fungsi Lambda ini juga digunakan dalam tutorial. AWS Cloud9 AWS Cloud9 adalah lingkungan pengembangan terintegrasi berbasis cloud. Untuk informasi tentang cara membuat, mengeksekusi, memperbarui, dan men-debug fungsi ini AWS Cloud9, lihat [AWS Lambda tutorial untuk AWS Cloud9](https://docs.aws.amazon.com/cloud9/latest/user-guide/tutorial-lambda.html). 

# Buat file untuk fungsi BeforeAllowTraffic Lambda Anda
<a name="tutorial-lambda-sam-create-lambda-before-traffic"></a>

Buat file untuk fungsi Lambda `beforeAllowTraffic` hook Anda.

1.  Buat file teks dan simpan seperti `beforeAllowTraffic.js` di `SAM-Tutorial` direktori. 

1.  Salin kode Node.js berikut ke dalam`beforeAllowTraffic.js`. Fungsi ini dijalankan selama hook penerapan Anda. `BeforeAllowTraffic` 

   ```
   'use strict';
       
       const AWS = require('aws-sdk'); 
       const codedeploy = new AWS.CodeDeploy({apiVersion: '2014-10-06'});
       var lambda = new AWS.Lambda();
       
       exports.handler = (event, context, callback) => {
       
       	console.log("Entering PreTraffic Hook!");
       	
       	// Read the DeploymentId and LifecycleEventHookExecutionId from the event payload
         var deploymentId = event.DeploymentId;
       	var lifecycleEventHookExecutionId = event.LifecycleEventHookExecutionId;
       
       	var functionToTest = process.env.NewVersion;
       	console.log("BeforeAllowTraffic hook tests started");
       	console.log("Testing new function version: " + functionToTest);
       
       	// Create parameters to pass to the updated Lambda function that
       	// include the newly added "time" option. If the function did not
       	// update, then the "time" option is invalid and function returns
       	// a statusCode of 400 indicating it failed.
       	var lambdaParams = {
       		FunctionName: functionToTest,    
       		Payload: "{\"option\": \"time\"}", 
       		InvocationType: "RequestResponse"
       	};
       
       	var lambdaResult = "Failed";
       	// Invoke the updated Lambda function.
       	lambda.invoke(lambdaParams, function(err, data) {
       		if (err){	// an error occurred
       			console.log(err, err.stack);
       			lambdaResult = "Failed";
       		}
       		else{	// successful response
       			var result = JSON.parse(data.Payload);
       			console.log("Result: " +  JSON.stringify(result));
             console.log("statusCode: " + result.statusCode);
             
             // Check if the status code returned by the updated
             // function is 400. If it is, then it failed. If 
             // is not, then it succeeded.
       			if (result.statusCode != "400"){
               console.log("Validation succeeded");
       				lambdaResult = "Succeeded";
             }
             else {
               console.log("Validation failed");
             }
       
       			// Complete the PreTraffic Hook by sending CodeDeploy the validation status
       			var params = {
       				deploymentId: deploymentId,
       				lifecycleEventHookExecutionId: lifecycleEventHookExecutionId,
       				status: lambdaResult // status can be 'Succeeded' or 'Failed'
       			};
       			
       			// Pass CodeDeploy the prepared validation test results.
       			codedeploy.putLifecycleEventHookExecutionStatus(params, function(err, data) {
       				if (err) {
       					// Validation failed.
       					console.log("CodeDeploy Status update failed");
       					console.log(err, err.stack);
       					callback("CodeDeploy Status update failed");
       				} else {
       					// Validation succeeded.
       					console.log("CodeDeploy status updated successfully");
       					callback(null, "CodeDeploy status updated successfully");
       				}
       			});
       		}  
       	});
       }
   ```

# Buat file untuk fungsi AfterAllowTraffic Lambda Anda
<a name="tutorial-lambda-sam-create-lambda-after-traffic"></a>

Buat file untuk fungsi Lambda `afterAllowTraffic` hook Anda.

1.  Buat file teks dan simpan seperti `afterAllowTraffic.js` di `SAM-Tutorial` direktori. 

1.  Salin kode Node.js berikut ke dalam`afterAllowTraffic.js`. Fungsi ini dijalankan selama hook penerapan Anda. `AfterAllowTraffic` 

   ```
   'use strict';
       
       const AWS = require('aws-sdk');
       const codedeploy = new AWS.CodeDeploy({apiVersion: '2014-10-06'});
       var lambda = new AWS.Lambda();
       
       exports.handler = (event, context, callback) => {
       
       	console.log("Entering PostTraffic Hook!");
       	
       	// Read the DeploymentId and LifecycleEventHookExecutionId from the event payload
         var deploymentId = event.DeploymentId;
       	var lifecycleEventHookExecutionId = event.LifecycleEventHookExecutionId;
       
       	var functionToTest = process.env.NewVersion;
       	console.log("AfterAllowTraffic hook tests started");
       	console.log("Testing new function version: " + functionToTest);
       
       	// Create parameters to pass to the updated Lambda function that
       	// include the original "date" parameter. If the function did not 
       	// update as expected, then the "date" option might be invalid. If 
       	// the parameter is invalid, the function returns
       	// a statusCode of 400 indicating it failed.
       	var lambdaParams = {
       		FunctionName: functionToTest,    
       		Payload: "{\"option\": \"date\", \"period\": \"today\"}", 
       		InvocationType: "RequestResponse"
       	};
       
       	var lambdaResult = "Failed";
       	// Invoke the updated Lambda function.
       	lambda.invoke(lambdaParams, function(err, data) {
       		if (err){	// an error occurred
       			console.log(err, err.stack);
       			lambdaResult = "Failed";
       		}
       		else{	// successful response
       			var result = JSON.parse(data.Payload);
       			console.log("Result: " +  JSON.stringify(result));
             console.log("statusCode: " + result.statusCode);
             
             // Check if the status code returned by the updated
             // function is 400. If it is, then it failed. If 
             // is not, then it succeeded.
       			if (result.statusCode != "400"){
               console.log("Validation of time parameter succeeded");
       				lambdaResult = "Succeeded";
             }
             else {
               console.log("Validation failed");
             }
       
       			// Complete the PostTraffic Hook by sending CodeDeploy the validation status
       			var params = {
       				deploymentId: deploymentId,
       				lifecycleEventHookExecutionId: lifecycleEventHookExecutionId,
       				status: lambdaResult // status can be 'Succeeded' or 'Failed'
       			};
       			
       			// Pass CodeDeploy the prepared validation test results.
       			codedeploy.putLifecycleEventHookExecutionStatus(params, function(err, data) {
       				if (err) {
       					// Validation failed.
       					console.log("CodeDeploy Status update failed");
       					console.log(err, err.stack);
       					callback("CodeDeploy Status update failed");
       				} else {
       					// Validation succeeded.
       					console.log("CodeDeploy status updated successfully");
       					callback(null, "CodeDeploy status updated successfully");
       				}
       			});
       		}  
       	});
       }
   ```

# Package aplikasi AWS SAM
<a name="tutorial-lambda-sam-package"></a>

 Anda sekarang harus memiliki empat file di `SAM-Tutorial` direktori Anda: 
+ `beforeAllowTraffic.js`
+ `afterAllowTraffic.js`
+ `myDateTimeFunction.js`
+ `template.yml`

 Anda sekarang siap menggunakan **sam package** perintah AWS SAM untuk membuat dan mengemas artefak untuk fungsi CodeDeploy dan aplikasi Lambda Anda. Artefak diunggah ke ember S3. Output dari perintah adalah file baru bernama`package.yml`. File ini digunakan oleh **sam deploy** perintah AWS SAM pada langkah berikutnya. 

**catatan**  
 Untuk informasi selengkapnya tentang **sam package** perintah, lihat [referensi perintah AWS SAM CLI di Panduan AWS Serverless Application Model](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-command-reference.html) *Pengembang*. 

 Di `SAM-Tutorial` direktori, jalankan yang berikut ini. 

```
sam package \
  --template-file template.yml \
  --output-template-file package.yml \
  --s3-bucket amzn-s3-demo-bucket
```

Untuk `s3-bucket` parameternya, tentukan bucket Amazon S3 yang Anda buat sebagai prasyarat untuk tutorial ini. `output-template-file`Menentukan nama file baru yang digunakan oleh **sam deploy** perintah AWS SAM.

# Menyebarkan aplikasi AWS SAM
<a name="tutorial-lambda-sam-deploy"></a>

 Gunakan **sam deploy** perintah AWS SAM dengan `package.yml` file untuk membuat fungsi Lambda Anda dan CodeDeploy aplikasi dan kelompok penyebaran menggunakan. CloudFormation

**catatan**  
Untuk informasi selengkapnya tentang **sam deploy** perintah, lihat [referensi perintah AWS SAM CLI di Panduan AWS Serverless Application Model](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-command-reference.html) *Pengembang*. 

 Dalam `SAM-Tutorial` direktori, jalankan perintah berikut. 

```
sam deploy \
  --template-file package.yml \
  --stack-name my-date-time-app \
  --capabilities CAPABILITY_IAM
```

 `--capabilities CAPABILITY_IAM`Parameter ini diperlukan untuk mengotorisasi CloudFormation untuk membuat peran IAM. 

# (Opsional) memeriksa dan menguji infrastruktur Anda
<a name="tutorial-lambda-sam-confirm-components"></a>

 Topik ini menunjukkan cara melihat komponen infrastruktur Anda dan menguji fungsi Lambda Anda. 

**Untuk melihat hasil tumpukan Anda setelah Anda menjalankan `sam deploy`**

1. Buka CloudFormation konsol di [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).

1.  Di panel navigasi, pilih **Stacks (Tumpukan)**. `my-date-time-app`Tumpukan muncul di bagian atas. 

1.  Pilih tab **Acara** untuk melihat acara mana yang selesai. Anda dapat melihat peristiwa saat pembuatan tumpukan sedang berlangsung. Saat pembuatan tumpukan selesai, Anda dapat melihat semua peristiwa pembuatan tumpukan. 

1.  Dengan tumpukan Anda dipilih, pilih **Resources**. Di kolom **Type**, Anda dapat melihat fungsi Lambda Anda,, `myDateTimeFunction``CodeDeployHook_beforeAllowTraffic`, dan. `CodeDeployHook_afterAllowTraffic` Kolom **ID Fisik** dari setiap fungsi Lambda Anda berisi tautan untuk melihat fungsi di konsol Lambda. 
**catatan**  
 Nama fungsi `myDateTimeFunction` Lambda ditambahkan dengan nama CloudFormation tumpukan dan memiliki pengenal yang ditambahkan ke dalamnya, jadi sepertinya. `my-date-time-app-myDateTimeFunction-123456ABCDEF` 

1. Buka CodeDeploy konsol di [https://console.aws.amazon.com/codedeploy/](https://console.aws.amazon.com/codedeploy/).

1.  **Di panel navigasi, perluas **Deploy**, lalu pilih Applications.** 

1.  Anda akan melihat CodeDeploy aplikasi baru yang dibuat CloudFormation dengan nama yang dimulai dengan`my-date-time-app-ServerlessDeploymentApplication`. Pilih aplikasi ini. 

1.  Anda akan melihat grup penyebaran dengan nama yang dimulai dengan`my-date-time-app-myDateTimeFunctionDeploymentGroup`. Pilih grup penyebaran ini. 

    **Di bawah **konfigurasi Deployment**, Anda akan melihatCodeDeployDefault. LambdaLinear10 PercentEvery 1 Menit**. 

**(Opsional) untuk menguji fungsi Anda (konsol)**

1. Buka AWS Lambda konsol di [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

1.  Dari panel navigasi, pilih `my-date-time-app-myDateTimeFunction` fungsi Anda. Di konsol, namanya berisi pengidentifikasi, jadi sepertinya`my-date-time-app-myDateTimeFunction-123456ABCDEF`. 

1.  Pilih **Uji**. 

1.  Dalam **nama Acara**, masukkan nama untuk acara pengujian Anda. 

1.  Masukkan yang berikut ini untuk acara pengujian Anda, lalu pilih **Buat**. 

   ```
   {
     "option": "date",
     "period": "today"
   }
   ```

1.  Pilih **Uji**. Anda hanya akan melihat acara pengujian Anda dalam daftar acara pengujian. 

    Untuk **hasil Eksekusi**, Anda akan melihat **berhasil.** 

1.  Di bawah **Hasil eksekusi**, perluas **Detail** untuk melihat hasilnya. Anda harus melihat bulan, hari, dan tahun saat ini. 

**(Opsional) untuk menguji fungsi Anda (AWS CLI)**

1.  Temukan ARN fungsi Lambda Anda. Itu muncul di bagian atas konsol Lambda saat Anda melihat fungsi Anda. 

1.  Jalankan perintah berikut. Ganti *your-function-arn* dengan fungsi ARN. 

   ```
   aws lambda invoke \
   --function your-function-arn \
   --cli-binary-format raw-in-base64-out \
   --payload "{\"option\": \"date\", \"period\": \"today\"}" out.txt
   ```

1.  Buka `out.txt` untuk mengonfirmasi hasilnya berisi bulan, hari, dan tahun saat ini. 

# Langkah 2: Perbarui fungsi Lambda
<a name="tutorial-lambda-sam-update-function"></a>

 Dalam topik ini, Anda memperbarui `myDateTimeFunction.js` file Anda. Pada langkah berikutnya, Anda menggunakan file untuk menyebarkan fungsi yang diperbarui. Ini memicu CodeDeploy untuk menerapkannya dengan mengalihkan lalu lintas produksi dari versi fungsi Lambda saat ini ke versi yang diperbarui. 

**Untuk memperbarui fungsi Lambda Anda**

1.  Buka `myDateTimeFunction.js`. 

1.  Hapus dua penanda komentar (” `/*` "dan" `*/` “) dan teks penjelasan di awal dan akhir yang `case` disebutkan `time` di `switch` blok. 

    Kode yang tidak dikomentari memungkinkan Anda meneruskan parameter baru,`time`, ke fungsi. Jika Anda meneruskan `time` ke fungsi yang diperbarui, ia mengembalikan arus`hour`,`minute`, dan`second`. 

1.  Simpan `myDateTimeFunction.js`. Seharusnya terlihat seperti berikut: 

   ```
   'use strict';
   
   exports.handler = function(event, context, callback) {
   
     if (event.body) {
       event = JSON.parse(event.body);
     }
   
     var sc; // Status code
     var result = ""; // Response payload
   
     switch(event.option) {
       case "date":
         switch(event.period) {
           case "yesterday":
             result = setDateResult("yesterday");
             sc = 200;
             break;
           case "today":
             result = setDateResult();
             sc = 200;
             break;
           case "tomorrow":
             result = setDateResult("tomorrow");
             sc = 200;
             break;
           default:
             result = {
               "error": "Must specify 'yesterday', 'today', or 'tomorrow'."
             };
             sc = 400;
             break;
         }
         break;
         case "time":
           var d = new Date();
           var h = d.getHours();
           var mi = d.getMinutes();
           var s = d.getSeconds();
   
           result = {
             "hour": h,
             "minute": mi,
             "second": s
           };
           sc = 200;
           break;
   
         default:
           result = {
             "error": "Must specify 'date' or 'time'."
           };
           sc = 400;
         break;
     }
   
     const response = {
       statusCode: sc,
       headers: { "Content-type": "application/json" },
       body: JSON.stringify( result )
     };
   
     callback(null, response);
   
     function setDateResult(option) {
   
       var d = new Date(); // Today
       var mo; // Month
       var da; // Day
       var y; // Year
   
       switch(option) {
         case "yesterday":
           d.setDate(d.getDate() - 1);
           break;
         case "tomorrow":
           d.setDate(d.getDate() + 1);
         default:
          break;
       }
   
       mo = d.getMonth() + 1; // Months are zero offset (0-11)
       da = d.getDate();
       y = d.getFullYear();
   
       result = {
         "month": mo,
         "day": da,
         "year": y
       };
   
       return result;
     }
   };
   ```

# Langkah 3: Menyebarkan fungsi Lambda yang diperbarui
<a name="tutorial-lambda-sam-deploy-update"></a>

 Pada langkah ini, Anda menggunakan pembaruan `myDateTimeFunction.js` untuk memperbarui dan memulai penerapan fungsi Lambda Anda. Anda dapat memantau kemajuan penerapan di AWS Lambda konsol CodeDeploy atau. 

 `AutoPublishAlias: live`Baris di AWS SAM template Anda menyebabkan infrastruktur Anda mendeteksi pembaruan fungsi yang menggunakan `live` alias. Pembaruan fungsi Anda memicu penerapan yang menggeser lalu lintas produksi dari versi asli fungsi ke versi yang diperbarui. CodeDeploy 

 **sam deploy**Perintah **sam package** dan digunakan untuk memperbarui dan memicu penyebaran fungsi Lambda Anda. Anda menjalankan perintah ini di [Package aplikasi AWS SAM](tutorial-lambda-sam-package.md) dan[Menyebarkan aplikasi AWS SAM](tutorial-lambda-sam-deploy.md). 

**Untuk menerapkan fungsi Lambda Anda yang diperbarui**

1.  Dalam `SAM-Tutorial` direktori, jalankan perintah berikut. 

   ```
   sam package \
     --template-file template.yml \
     --output-template-file package.yml  \
     --s3-bucket amzn-s3-demo-bucket
   ```

    Ini membuat kumpulan artefak baru yang mereferensikan fungsi Lambda Anda yang diperbarui di bucket S3 Anda. 

1.  Dalam `SAM-Tutorial` direktori, jalankan perintah berikut. 

   ```
   sam deploy \
     --template-file package.yml \
     --stack-name my-date-time-app \
     --capabilities CAPABILITY_IAM
   ```

   Karena nama tumpukan masih`my-date-time-app`, CloudFormation mengakui bahwa ini adalah pembaruan tumpukan. Untuk melihat tumpukan yang diperbarui, kembalikan CloudFormation konsol, dan dari panel navigasi, pilih **Tumpukan**.

**(Opsional) untuk melihat lalu lintas selama penerapan (CodeDeploy konsol)**

1. Buka CodeDeploy konsol di [https://console.aws.amazon.com/codedeploy/](https://console.aws.amazon.com/codedeploy/).

1.  Di panel navigasi, perluas **Aplikasi**, lalu pilih **my-date-time-app- ServerlessDeploymentApplication** aplikasi Anda. 

1.  Di **grup Deployment**, pilih grup penerapan aplikasi Anda. Statusnya harus **Sedang berlangsung**. 

1.  Dalam **riwayat grup Deployment**, pilih penerapan yang sedang berlangsung. 

   Bilah kemajuan **pergeseran lalu lintas** dan persentase di kotak **Asli** dan **Penggantian** di halaman ini menampilkan kemajuannya.   
![\[Bagian kemajuan pergeseran lalu lintas CodeDeploy konsol.\]](http://docs.aws.amazon.com/id_id/codedeploy/latest/userguide/images/lambda-tutorial-codedeploy-console-20-percent-deployed.png)

**(Opsional) untuk melihat lalu lintas selama penerapan (konsol Lambda)**

1. Buka AWS Lambda konsol di [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

1.  Dari panel navigasi, pilih `my-date-time-app-myDateTimeFunction` fungsi Anda. Di konsol, namanya berisi pengidentifikasi, jadi sepertinya`my-date-time-app-myDateTimeFunction-123456ABCDEF`. 

1.  Pilih **Alias**, lalu pilih **live**. 

Bobot di sebelah versi fungsi asli Anda (versi 1) dan versi fungsi yang diperbarui (versi 2) menunjukkan berapa banyak lalu lintas yang disajikan ke setiap versi pada saat halaman AWS Lambda konsol ini dimuat. Halaman tidak memperbarui bobot dari waktu ke waktu. Jika Anda me-refresh halaman sekali dalam satu menit, berat untuk versi 1 berkurang 10 persen dan berat untuk versi 2 meningkat 10 persen hingga bobot untuk versi 2 adalah 100. 

![\[Bagian alias CodeDeploy konsol.\]](http://docs.aws.amazon.com/id_id/codedeploy/latest/userguide/images/lambda-tutorial-lambda-console-20-percent-deployed.png)


# Langkah 4: Lihat hasil penerapan Anda
<a name="tutorial-lambda-sam-deploy-view-results"></a>

Pada langkah ini, Anda melihat hasil penerapan Anda. Jika penerapan berhasil, Anda dapat mengonfirmasi bahwa fungsi Lambda yang diperbarui menerima lalu lintas produksi. Jika penerapan gagal, Anda dapat menggunakan CloudWatch Log untuk melihat output pengujian validasi dalam fungsi Lambda yang berjalan selama hoook siklus hidup penerapan. 

**Topics**
+ [Uji fungsi yang Anda gunakan](#tutorial-lambda-sam-deploy-test-deployed-function)
+ [Lihat peristiwa hook di CloudWatch Log](#tutorial-lambda-view-hook-events)

## Uji fungsi yang Anda gunakan
<a name="tutorial-lambda-sam-deploy-test-deployed-function"></a>

 **sam deploy**Perintah memperbarui fungsi `my-date-time-app-myDateTimeFunction` Lambda. Versi fungsi diperbarui ke 2 dan ditambahkan ke `live` alias. 

**Untuk melihat pembaruan di konsol Lambda**

1. Buka AWS Lambda konsol di [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

1.  Dari panel navigasi, pilih `my-date-time-app-myDateTimeFunction` fungsinya. Di konsol, namanya berisi pengidentifikasi, jadi sepertinya`my-date-time-app-myDateTimeFunction-123456ABCDEF`. 

1.  Pilih **Kualifikasi**, lalu pilih **Alias**. Setelah penerapan selesai (sekitar 10 menit), untuk `live` alias, Anda akan melihat **Versi: 2**.  
![\[Bagian alias CodeDeploy konsol.\]](http://docs.aws.amazon.com/id_id/codedeploy/latest/userguide/images/lambda-tutorial-function-version.png)

1.  Dalam **kode Fungsi**, lihat kode sumber untuk fungsi Anda. Perubahan Anda akan muncul. 

1.  (Opsional) Anda dapat menggunakan instruksi pengujian [Langkah 2: Perbarui fungsi Lambda](tutorial-lambda-sam-update-function.md) untuk menguji fungsi Anda yang diperbarui. Buat acara pengujian baru dengan muatan berikut, lalu konfirmasikan hasilnya berisi jam, menit, dan detik saat ini. 

   ```
   {
       "option": "time"
     }
   ```

    Untuk menggunakan fungsi AWS CLI to test yang diperbarui, jalankan perintah berikut, lalu buka `out.txt` untuk mengonfirmasi hasilnya berisi jam, menit, dan detik saat ini. 

   ```
   aws lambda invoke --function your-function-arn --payload "{\"option\": \"time\"}" out.txt 
   ```
**catatan**  
 Jika Anda menggunakan AWS CLI untuk menguji fungsi Anda sebelum penerapan selesai, Anda mungkin menerima hasil yang tidak terduga. Ini karena CodeDeploy secara bertahap menggeser 10 persen lalu lintas ke versi yang diperbarui setiap menit. Selama penyebaran, beberapa lalu lintas masih menunjuk ke versi aslinya, jadi `aws lambda invoke` mungkin menggunakan versi aslinya. Setelah 10 menit, penyebaran selesai dan semua lalu lintas menunjuk ke versi baru fungsi. 

## Lihat peristiwa hook di CloudWatch Log
<a name="tutorial-lambda-view-hook-events"></a>

 Selama `BeforeAllowTraffic` hook, CodeDeploy jalankan fungsi `CodeDeployHook_beforeAllowTraffic` Lambda Anda. Selama `AfterAllowTraffic` hook, CodeDeploy jalankan fungsi `CodeDeployHook_afterAllowTraffic` Lambda Anda. Setiap fungsi menjalankan uji validasi yang memanggil versi terbaru dari fungsi Anda menggunakan parameter baru`time`. Jika pembaruan fungsi Lambda Anda berhasil, `time` opsi tidak menyebabkan kesalahan dan validasi berhasil. Jika fungsi tidak diperbarui, parameter yang tidak dikenal menyebabkan kesalahan dan validasi gagal. Tes validasi ini hanya untuk tujuan demonstrasi. Anda menulis pengujian Anda sendiri untuk memvalidasi penerapan Anda. Anda dapat menggunakan konsol CloudWatch Log untuk melihat pengujian validasi Anda. 

**Untuk melihat acara CodeDeploy hook Anda**

1. Buka CloudWatch konsol di [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1.  Dari panel navigasi, pilih **Log**. 

1.  Dari daftar grup log, pilih**/aws/lambda/CodeDeployHook\$1 beforeAllowTraffic** atau**/aws/lambda/CodeDeployHook\$1 afterAllowTraffic**. 

1.  Pilih pengaliran log. Anda harus melihat hanya satu. 

1.  Perluas acara untuk melihat detailnya.   
![\[Aliran log dari grup CodeDeployHook log.\]](http://docs.aws.amazon.com/id_id/codedeploy/latest/userguide/images/lambda-tutorial-cloudwatch.png)

# Langkah 5: Bersihkan
<a name="tutorial-lambda-clean-up"></a>

Untuk menghindari biaya lebih lanjut untuk sumber daya yang Anda gunakan selama tutorial ini, hapus sumber daya yang dibuat oleh AWS SAM template Anda dan CloudWatch log yang dibuat oleh fungsi validasi Lambda Anda.

**Untuk menghapus CloudFormation tumpukan Anda**

1. Masuk ke Konsol Manajemen AWS dan buka CloudFormation konsol di [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).

1. Di kolom **Stacks**, pilih `my-date-time-app` tumpukan Anda, lalu pilih **Hapus**.

1. Saat diminta, pilih **Hapus tumpukan**. Fungsi Lambda, grup CodeDeploy aplikasi dan penyebaran, dan peran IAM yang dibuat oleh dihapus. AWS SAM 

**Untuk menghapus log Anda di CloudWatch Log**

1. Buka CloudWatch konsol di [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).

1.  Dari panel navigasi, pilih **Log**. 

1.  Dari daftar grup log, pilih tombol di sebelah**/aws/lambda/CodeDeployHook\$1 beforeAllowTraffic**. 

1.  Dari **Tindakan**, pilih **Hapus grup log**, lalu pilih **Ya, Hapus**. 

1.  Dari daftar grup log, pilih tombol di sebelah**/aws/lambda/CodeDeployHook\$1 afterAllowTraffic**. 

1.  Dari **Tindakan**, pilih **Hapus grup log**, lalu pilih **Ya, Hapus**.