Ini adalah Panduan Pengembang AWS CDK v2. CDK v1 yang lebih lama memasuki pemeliharaan pada 1 Juni 2022 dan mengakhiri dukungan pada 1 Juni 2023.
Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Tutorial: Buat aplikasi Hello World tanpa server
Dalam tutorial ini, Anda menggunakan AWS Cloud Development Kit (AWS CDK) untuk membuat `Hello World` aplikasi tanpa server sederhana yang mengimplementasikan backend API dasar yang terdiri dari berikut ini:
+ **Amazon API Gateway REST API** — Menyediakan titik akhir HTTP yang digunakan untuk menjalankan fungsi Anda melalui permintaan HTTP GET.
+ AWS Fungsi **Lambda - Fungsi** yang mengembalikan `Hello World!` pesan saat dipanggil dengan titik akhir HTTP.
+ **Integrasi dan izin** — Detail konfigurasi dan izin untuk sumber daya Anda untuk berinteraksi satu sama lain dan melakukan tindakan, seperti menulis log ke Amazon. CloudWatch
Diagram berikut menunjukkan komponen dari aplikasi ini:
![\[Diagram fungsi Lambda yang dipanggil saat Anda mengirim permintaan GET ke titik akhir API Gateway.\]](http://docs.aws.amazon.com/id_id/cdk/v2/guide/images/serverless-example-01.png)
Untuk tutorial ini, Anda akan membuat dan berinteraksi dengan aplikasi Anda dalam langkah-langkah berikut:
1. Buat proyek AWS CDK.
1. Tentukan fungsi Lambda dan API REST API Gateway API menggunakan konstruksi L2 dari Construct Library. AWS
1. Terapkan aplikasi Anda ke AWS Cloud.
1. Berinteraksi dengan aplikasi Anda di AWS Cloud.
1. Hapus contoh aplikasi dari AWS Cloud.
## Prasyarat
Sebelum memulai tutorial ini, selesaikan yang berikut ini:
+ Buat AWS akun dan instal dan konfigurasi AWS Command Line Interface (AWS CLI).
+ Instal Node.js dan`npm`.
+ Instal CDK Toolkit secara global, menggunakan. `npm install -g aws-cdk`
Untuk informasi selengkapnya, lihat [Memulai AWS CDK](getting-started.md).
Kami juga merekomendasikan pemahaman dasar tentang hal-hal berikut:
+ [Apa itu AWS CDK?](home.md) untuk pengenalan dasar AWS CDK.
+ [Pelajari konsep inti AWS CDK](core-concepts.md) untuk ikhtisar konsep inti AWS CDK.
## Langkah 1: Buat proyek CDK
Pada langkah ini, Anda membuat proyek CDK baru menggunakan perintah AWS CDK CLI. `cdk init`
**Untuk membuat proyek CDK**
1. Dari direktori awal pilihan Anda, buat dan navigasikan ke direktori proyek yang diberi nama `cdk-hello-world` di mesin Anda:
```
$ mkdir cdk-hello-world && cd cdk-hello-world
```
1. Gunakan `cdk init` perintah untuk membuat proyek baru dalam bahasa pemrograman pilihan Anda:
**Example**
------
#### [ TypeScript ]
```
$ cdk init --language typescript
```
Instal perpustakaan AWS CDK:
```
$ npm install aws-cdk-lib constructs
```
------
#### [ JavaScript ]
```
$ cdk init --language javascript
```
Instal perpustakaan AWS CDK:
```
$ npm install aws-cdk-lib constructs
```
------
#### [ Python ]
```
$ cdk init --language python
```
Aktifkan lingkungan virtual:
```
$ source .venv/bin/activate # On Windows, run '.\venv\Scripts\activate' instead
```
Instal perpustakaan AWS CDK dan dependensi proyek:
```
(.venv)$ python3 -m pip install -r requirements.txt
```
------
#### [ Java ]
```
$ cdk init --language java
```
Instal perpustakaan AWS CDK dan dependensi proyek:
```
$ mvn package
```
------
#### [ C\$1 ]
```
$ cdk init --language csharp
```
Instal perpustakaan AWS CDK dan dependensi proyek:
```
$ dotnet restore src
```
------
#### [ Go ]
```
$ cdk init --language go
```
Instal dependensi proyek:
```
$ go get github.com/aws/aws-cdk-go/awscdk/v2
$ go get github.com/aws/aws-cdk-go/awscdk/v2/awslambda
$ go get github.com/aws/aws-cdk-go/awscdk/v2/awsapigateway
$ go mod tidy
```
------
CDK CLI membuat proyek dengan struktur berikut:
**Example**
------
#### [ TypeScript ]
```
cdk-hello-world
├── .git
├── .gitignore
├── .npmignore
├── README.md
├── bin
│ └── cdk-hello-world.ts
├── cdk.json
├── jest.config.js
├── lib
│ └── cdk-hello-world-stack.ts
├── node_modules
├── package-lock.json
├── package.json
├── test
│ └── cdk-hello-world.test.ts
└── tsconfig.json
```
------
#### [ JavaScript ]
```
cdk-hello-world
├── .git
├── .gitignore
├── .npmignore
├── README.md
├── bin
│ └── cdk-hello-world.js
├── cdk.json
├── jest.config.js
├── lib
│ └── cdk-hello-world-stack.js
├── node_modules
├── package-lock.json
├── package.json
└── test
└── cdk-hello-world.test.js
```
------
#### [ Python ]
```
cdk-hello-world
├── .git
├── .gitignore
├── .venv
├── README.md
├── app.py
├── cdk.json
├── cdk_hello_world
│ ├── __init__.py
│ └── cdk_hello_world_stack.py
├── requirements-dev.txt
├── requirements.txt
├── source.bat
└── tests
```
------
#### [ Java ]
```
cdk-hello-world
├── .git
├── .gitignore
├── README.md
├── cdk.json
├── pom.xml
├── src
│ ├── main
│ │ └── java
│ │ └── com
│ │ └── myorg
│ │ ├── CdkHelloWorldApp.java
│ │ └── CdkHelloWorldStack.java
└── target
```
------
#### [ C\$1 ]
```
cdk-hello-world
├── .git
├── .gitignore
├── README.md
├── cdk.json
└── src
├── CdkHelloWorld
│ ├── CdkHelloWorld.csproj
│ ├── CdkHelloWorldStack.cs
│ ├── GlobalSuppressions.cs
│ └── Program.cs
└── CdkHelloWorld.sln
```
------
#### [ Go ]
```
cdk-hello-world
├── .git
├── .gitignore
├── README.md
├── cdk-hello-world.go
├── cdk-hello-world_test.go
├── cdk.json
├── go.mod
└── go.sum
```
------
CDK CLI secara otomatis membuat aplikasi CDK yang berisi satu tumpukan. Instance aplikasi CDK dibuat dari ` [App](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.App.html) ` kelas. Berikut ini adalah bagian dari file aplikasi CDK Anda:
**Example**
Terletak di`bin/cdk-hello-world.ts`:
```
#!/usr/bin/env node
import 'source-map-support/register';
import * as cdk from 'aws-cdk-lib';
import { CdkHelloWorldStack } from '../lib/cdk-hello-world-stack';
const app = new cdk.App();
new CdkHelloWorldStack(app, 'CdkHelloWorldStack', {
});
```
Terletak di`bin/cdk-hello-world.js`:
```
#!/usr/bin/env node
const cdk = require('aws-cdk-lib');
const { CdkHelloWorldStack } = require('../lib/cdk-hello-world-stack');
const app = new cdk.App();
new CdkHelloWorldStack(app, 'CdkHelloWorldStack', {
});
```
Terletak di`app.py`:
```
#!/usr/bin/env python3
import os
import aws_cdk as cdk
from cdk_hello_world.cdk_hello_world_stack import CdkHelloWorldStack
app = cdk.App()
CdkHelloWorldStack(app, "CdkHelloWorldStack",)
app.synth()
```
Terletak di`src/main/java/…/CdkHelloWorldApp.java`:
```
package com.myorg;
import software.amazon.awscdk.App;
import software.amazon.awscdk.Environment;
import software.amazon.awscdk.StackProps;
import java.util.Arrays;
public class JavaApp {
public static void main(final String[] args) {
App app = new App();
new JavaStack(app, "JavaStack", StackProps.builder()
.build());
app.synth();
}
}
```
Terletak di`src/CdkHelloWorld/Program.cs`:
```
using Amazon.CDK;
using System;
using System.Collections.Generic;
using System.Linq;
namespace CdkHelloWorld
{
sealed class Program
{
public static void Main(string[] args)
{
var app = new App();
new CdkHelloWorldStack(app, "CdkHelloWorldStack", new StackProps
{
});
app.Synth();
}
}
}
```
Terletak di`cdk-hello-world.go`:
```
package main
import (
"github.com/aws/aws-cdk-go/awscdk/v2"
"github.com/aws/constructs-go/constructs/v10"
"github.com/aws/jsii-runtime-go"
)
// ...
func main() {
defer jsii.Close()
app := awscdk.NewApp(nil)
NewCdkHelloWorldStack(app, "CdkHelloWorldStack", &CdkHelloWorldStackProps{
awscdk.StackProps{
Env: env(),
},
})
app.Synth(nil)
}
func env() *awscdk.Environment {
return nil
}
```
## Langkah 2: Buat fungsi Lambda Anda
Dalam proyek CDK Anda, buat `lambda` direktori yang menyertakan `hello.js` file baru. Berikut ini adalah contohnya:
**Example**
Dari akar proyek Anda, jalankan yang berikut ini:
```
$ mkdir lambda && cd lambda
$ touch hello.js
```
Berikut ini sekarang harus ditambahkan ke proyek CDK Anda:
```
cdk-hello-world
└── lambda
└── hello.js
```
Dari akar proyek Anda, jalankan yang berikut ini:
```
$ mkdir lambda && cd lambda
$ touch hello.js
```
Berikut ini sekarang harus ditambahkan ke proyek CDK Anda:
```
cdk-hello-world
└── lambda
└── hello.js
```
Dari akar proyek Anda, jalankan yang berikut ini:
```
$ mkdir lambda && cd lambda
$ touch hello.js
```
Berikut ini sekarang harus ditambahkan ke proyek CDK Anda:
```
cdk-hello-world
└── lambda
└── hello.js
```
Dari akar proyek Anda, jalankan yang berikut ini:
```
$ mkdir -p src/main/resources/lambda
$ cd src/main/resources/lambda
$ touch hello.js
```
Berikut ini sekarang harus ditambahkan ke proyek CDK Anda:
```
cdk-hello-world
└── src
└── main
└──resources
└──lambda
└──hello.js
```
Dari akar proyek Anda, jalankan yang berikut ini:
```
$ mkdir lambda && cd lambda
$ touch hello.js
```
Berikut ini sekarang harus ditambahkan ke proyek CDK Anda:
```
cdk-hello-world
└── lambda
└── hello.js
```
Dari akar proyek Anda, jalankan yang berikut ini:
```
$ mkdir lambda && cd lambda
$ touch hello.js
```
Berikut ini sekarang harus ditambahkan ke proyek CDK Anda:
```
cdk-hello-world
└── lambda
└── hello.js
```
**catatan**
Untuk menjaga tutorial ini sederhana, kita menggunakan fungsi JavaScript Lambda untuk semua bahasa pemrograman CDK.
Tentukan fungsi Lambda Anda dengan menambahkan yang berikut ini ke file yang baru dibuat:
```
exports.handler = async (event) => {
return {
statusCode: 200,
headers: { "Content-Type": "text/plain" },
body: JSON.stringify({ message: "Hello, World!" }),
};
};
```
## Langkah 3: Tentukan konstruksi Anda
Pada langkah ini, Anda akan menentukan sumber daya Lambda dan API Gateway Anda menggunakan konstruksi AWS CDK L2.
Buka file proyek yang mendefinisikan tumpukan CDK Anda. Anda akan memodifikasi file ini untuk menentukan konstruksi Anda. Berikut ini adalah contoh file stack awal Anda:
**Example**
Terletak di`lib/cdk-hello-world-stack.ts`:
```
import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
export class CdkHelloWorldStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Your constructs will go here
}
}
```
Terletak di`lib/cdk-hello-world-stack.js`:
```
const { Stack, Duration } = require('aws-cdk-lib');
const lambda = require('aws-cdk-lib/aws-lambda');
const apigateway = require('aws-cdk-lib/aws-apigateway');
class CdkHelloWorldStack extends Stack {
constructor(scope, id, props) {
super(scope, id, props);
// Your constructs will go here
}
}
module.exports = { CdkHelloWorldStack }
```
Terletak di`cdk_hello_world/cdk_hello_world_stack.py`:
```
from aws_cdk import Stack
from constructs import Construct
class CdkHelloWorldStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
// Your constructs will go here
```
Terletak di`src/main/java/…/CdkHelloWorldStack.java`:
```
package com.myorg;
import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;
public class CdkHelloWorldStack extends Stack {
public CdkHelloWorldStack(final Construct scope, final String id) {
this(scope, id, null);
}
public CdkHelloWorldStack(final Construct scope, final String id, final StackProps props) {
super(scope, id, props);
// Your constructs will go here
}
}
```
Terletak di`src/CdkHelloWorld/CdkHelloWorldStack.cs`:
```
using Amazon.CDK;
using Constructs;
namespace CdkHelloWorld
{
public class CdkHelloWorldStack : Stack
{
internal CdkHelloWorldStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
// Your constructs will go here
}
}
}
```
Terletak di`cdk-hello-world.go`:
```
package main
import (
"github.com/aws/aws-cdk-go/awscdk/v2"
"github.com/aws/constructs-go/constructs/v10"
"github.com/aws/jsii-runtime-go"
)
type CdkHelloWorldStackProps struct {
awscdk.StackProps
}
func NewCdkHelloWorldStack(scope constructs.Construct, id string, props *CdkHelloWorldStackProps) awscdk.Stack {
var sprops awscdk.StackProps
if props != nil {
sprops = props.StackProps
}
stack := awscdk.NewStack(scope, &id, &sprops)
// Your constructs will go here
return stack
}
func main() {
// ...
}
func env() *awscdk.Environment {
return nil
}
```
Dalam file ini, AWS CDK melakukan hal berikut:
+ Instans tumpukan CDK Anda dipakai dari kelas. ` [Stack](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Stack.html) `
+ Kelas ` [Constructs](https://docs.aws.amazon.com/cdk/api/v2/docs/constructs-readme.html) ` dasar diimpor dan disediakan sebagai lingkup atau induk dari instance tumpukan Anda.
### Tentukan sumber daya fungsi Lambda Anda
Untuk menentukan sumber daya fungsi Lambda, Anda mengimpor dan menggunakan konstruksi ` [aws-lambda](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html) ` L2 dari Perpustakaan Konstruksi. AWS
Ubah file tumpukan Anda sebagai berikut:
**Example**
```
import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
// Import Lambda L2 construct
import * as lambda from 'aws-cdk-lib/aws-lambda';
export class CdkHelloWorldStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Define the Lambda function resource
const helloWorldFunction = new lambda.Function(this, 'HelloWorldFunction', {
runtime: lambda.Runtime.NODEJS_20_X, // Choose any supported Node.js runtime
code: lambda.Code.fromAsset('lambda'), // Points to the lambda directory
handler: 'hello.handler', // Points to the 'hello' file in the lambda directory
});
}
}
```
```
const { Stack, Duration } = require('aws-cdk-lib');
// Import Lambda L2 construct
const lambda = require('aws-cdk-lib/aws-lambda');
class CdkHelloWorldStack extends Stack {
constructor(scope, id, props) {
super(scope, id, props);
// Define the Lambda function resource
const helloWorldFunction = new lambda.Function(this, 'HelloWorldFunction', {
runtime: lambda.Runtime.NODEJS_20_X, // Choose any supported Node.js runtime
code: lambda.Code.fromAsset('lambda'), // Points to the lambda directory
handler: 'hello.handler', // Points to the 'hello' file in the lambda directory
});
}
}
module.exports = { CdkHelloWorldStack }
```
```
from aws_cdk import (
Stack,
# Import Lambda L2 construct
aws_lambda as _lambda,
)
# ...
class CdkHelloWorldStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# Define the Lambda function resource
hello_world_function = _lambda.Function(
self,
"HelloWorldFunction",
runtime = _lambda.Runtime.NODEJS_20_X, # Choose any supported Node.js runtime
code = _lambda.Code.from_asset("lambda"), # Points to the lambda directory
handler = "hello.handler", # Points to the 'hello' file in the lambda directory
)
```
Kami mengimpor `aws_lambda` modul sebagai `\_lambda` because `lambda` adalah pengenal bawaan dengan Python.
```
// ...
// Import Lambda L2 construct
import software.amazon.awscdk.services.lambda.Code;
import software.amazon.awscdk.services.lambda.Function;
import software.amazon.awscdk.services.lambda.Runtime;
public class CdkHelloWorldStack extends Stack {
public CdkHelloWorldStack(final Construct scope, final String id) {
this(scope, id, null);
}
public CdkHelloWorldStack(final Construct scope, final String id, final StackProps props) {
super(scope, id, props);
// Define the Lambda function resource
Function helloWorldFunction = Function.Builder.create(this, "HelloWorldFunction")
.runtime(Runtime.NODEJS_20_X) // Choose any supported Node.js runtime
.code(Code.fromAsset("src/main/resources/lambda")) // Points to the lambda directory
.handler("hello.handler") // Points to the 'hello' file in the lambda directory
.build();
}
}
```
```
// ...
// Import Lambda L2 construct
using Amazon.CDK.AWS.Lambda;
namespace CdkHelloWorld
{
public class CdkHelloWorldStack : Stack
{
internal CdkHelloWorldStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
// Define the Lambda function resource
var helloWorldFunction = new Function(this, "HelloWorldFunction", new FunctionProps
{
Runtime = Runtime.NODEJS_20_X, // Choose any supported Node.js runtime
Code = Code.FromAsset("lambda"), // Points to the lambda directory
Handler = "hello.handler" // Points to the 'hello' file in the lambda directory
});
}
}
}
```
```
package main
import (
// ...
// Import Lambda L2 construct
"github.com/aws/aws-cdk-go/awscdk/v2/awslambda"
// Import S3 assets construct
"github.com/aws/aws-cdk-go/awscdk/v2/awss3assets"
// ...
)
// ...
func NewCdkHelloWorldStack(scope constructs.Construct, id string, props *CdkHelloWorldStackProps) awscdk.Stack {
var sprops awscdk.StackProps
if props != nil {
sprops = props.StackProps
}
stack := awscdk.NewStack(scope, &id, &sprops)
// Define the Lambda function resource
helloWorldFunction := awslambda.NewFunction(stack, jsii.String("HelloWorldFunction"), &awslambda.FunctionProps{
Runtime: awslambda.Runtime_NODEJS_20_X(), // Choose any supported Node.js runtime
Code: awslambda.Code_FromAsset(jsii.String("lambda"), &awss3assets.AssetOptions{}), // Points to the lambda directory
Handler: jsii.String("hello.handler"), // Points to the 'hello' file in the lambda directory
})
return stack
}
// ...
```
Di sini, Anda membuat sumber daya fungsi Lambda dan menentukan properti berikut:
+ `runtime`— Lingkungan tempat fungsi berjalan. Di sini, kami menggunakan Node.js versi 20.x.
+ `code`— Jalur ke kode fungsi pada mesin lokal Anda.
+ `handler`— Nama file tertentu yang berisi kode fungsi Anda.
### Tentukan sumber daya API REST API Gateway Anda
Untuk menentukan REST API resource API Gateway, Anda mengimpor dan menggunakan konstruksi ` [aws-apigateway](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_apigateway-readme.html) ` L2 dari Construct Library AWS .
Ubah file tumpukan Anda sebagai berikut:
**Example**
```
// ...
//Import API Gateway L2 construct
import * as apigateway from 'aws-cdk-lib/aws-apigateway';
export class CdkHelloWorldStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// ...
// Define the API Gateway resource
const api = new apigateway.LambdaRestApi(this, 'HelloWorldApi', {
handler: helloWorldFunction,
proxy: false,
});
// Define the '/hello' resource with a GET method
const helloResource = api.root.addResource('hello');
helloResource.addMethod('GET');
}
}
```
```
// ...
// Import API Gateway L2 construct
const apigateway = require('aws-cdk-lib/aws-apigateway');
class CdkHelloWorldStack extends Stack {
constructor(scope, id, props) {
super(scope, id, props);
// ...
// Define the API Gateway resource
const api = new apigateway.LambdaRestApi(this, 'HelloWorldApi', {
handler: helloWorldFunction,
proxy: false,
});
// Define the '/hello' resource with a GET method
const helloResource = api.root.addResource('hello');
helloResource.addMethod('GET');
};
};
// ...
```
```
from aws_cdk import (
# ...
# Import API Gateway L2 construct
aws_apigateway as apigateway,
)
from constructs import Construct
class CdkHelloWorldStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# ...
# Define the API Gateway resource
api = apigateway.LambdaRestApi(
self,
"HelloWorldApi",
handler = hello_world_function,
proxy = False,
)
# Define the '/hello' resource with a GET method
hello_resource = api.root.add_resource("hello")
hello_resource.add_method("GET")
```
```
// ...
// Import API Gateway L2 construct
import software.amazon.awscdk.services.apigateway.LambdaRestApi;
import software.amazon.awscdk.services.apigateway.Resource;
public class CdkHelloWorldStack extends Stack {
public CdkHelloWorldStack(final Construct scope, final String id) {
this(scope, id, null);
}
public CdkHelloWorldStack(final Construct scope, final String id, final StackProps props) {
super(scope, id, props);
// ...
// Define the API Gateway resource
LambdaRestApi api = LambdaRestApi.Builder.create(this, "HelloWorldApi")
.handler(helloWorldFunction)
.proxy(false) // Turn off default proxy integration
.build();
// Define the '/hello' resource and its GET method
Resource helloResource = api.getRoot().addResource("hello");
helloResource.addMethod("GET");
}
}
```
```
// ...
// Import API Gateway L2 construct
using Amazon.CDK.AWS.APIGateway;
namespace CdkHelloWorld
{
public class CdkHelloWorldStack : Stack
{
internal CdkHelloWorldStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
// ...
// Define the API Gateway resource
var api = new LambdaRestApi(this, "HelloWorldApi", new LambdaRestApiProps
{
Handler = helloWorldFunction,
Proxy = false
});
// Add a '/hello' resource with a GET method
var helloResource = api.Root.AddResource("hello");
helloResource.AddMethod("GET");
}
}
}
```
```
// ...
import (
// ...
// Import Api Gateway L2 construct
"github.com/aws/aws-cdk-go/awscdk/v2/awsapigateway"
// ...
)
// ...
func NewCdkHelloWorldStack(scope constructs.Construct, id string, props *CdkHelloWorldStackProps) awscdk.Stack {
var sprops awscdk.StackProps
if props != nil {
sprops = props.StackProps
}
stack := awscdk.NewStack(scope, &id, &sprops)
// Define the Lambda function resource
// ...
// Define the API Gateway resource
api := awsapigateway.NewLambdaRestApi(stack, jsii.String("HelloWorldApi"), &awsapigateway.LambdaRestApiProps{
Handler: helloWorldFunction,
Proxy: jsii.Bool(false),
})
// Add a '/hello' resource with a GET method
helloResource := api.Root().AddResource(jsii.String("hello"), &awsapigateway.ResourceOptions{})
helloResource.AddMethod(jsii.String("GET"), awsapigateway.NewLambdaIntegration(helloWorldFunction, &awsapigateway.LambdaIntegrationOptions{}), &awsapigateway.MethodOptions{})
return stack
}
// ...
```
Di sini, Anda membuat resource API Gateway REST API, bersama dengan yang berikut ini:
+ Integrasi antara REST API dan fungsi Lambda Anda, memungkinkan API untuk menjalankan fungsi Anda. Ini termasuk pembuatan sumber daya izin Lambda.
+ Sumber daya atau jalur baru bernama `hello` yang ditambahkan ke root titik akhir API. Ini menciptakan titik akhir baru yang `/hello` menambah URL dasar Anda.
+ Metode GET untuk `hello` sumber daya. Ketika permintaan GET dikirim ke `/hello` titik akhir, fungsi Lambda dipanggil dan responsnya dikembalikan.
## Langkah 4: Siapkan aplikasi Anda untuk penyebaran
Pada langkah ini Anda mempersiapkan aplikasi Anda untuk penyebaran dengan membangun, jika perlu, dan melakukan validasi dasar dengan perintah AWS CDK CLI`cdk synth`.
Jika perlu, buat aplikasi Anda:
**Example**
Dari akar proyek Anda, jalankan yang berikut ini:
```
$ npm run build
```
Bangunan tidak diperlukan.
Bangunan tidak diperlukan.
Dari akar proyek Anda, jalankan yang berikut ini:
```
$ mvn package
```
Dari akar proyek Anda, jalankan yang berikut ini:
```
$ dotnet build src
```
Bangunan tidak diperlukan.
Jalankan `cdk synth` untuk mensintesis AWS CloudFormation template dari kode CDK Anda. Dengan menggunakan konstruksi L2, banyak detail konfigurasi yang diperlukan AWS CloudFormation untuk memfasilitasi interaksi antara fungsi Lambda Anda dan REST API disediakan untuk Anda oleh CDK. AWS
Dari akar proyek Anda, jalankan yang berikut ini:
```
$ cdk synth
```
**catatan**
Jika Anda menerima kesalahan seperti berikut ini, verifikasi bahwa Anda berada di `cdk-hello-world` direktori dan coba lagi:
```
--app is required either in command-line, in cdk.json or in ~/.cdk.json
```
Jika berhasil, AWS CDK CLI akan menampilkan template AWS CloudFormation `YAML` dalam format pada prompt perintah. Template `JSON` yang diformat juga disimpan di `cdk.out` direktori.
Berikut ini adalah contoh output dari AWS CloudFormation template:
### AWS CloudFormation template
```
Resources:
HelloWorldFunctionServiceRoleunique-identifier:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Statement:
- Action: sts:AssumeRole
Effect: Allow
Principal:
Service: lambda.amazonaws.com
Version: "2012-10-17"
ManagedPolicyArns:
- Fn::Join:
- ""
- - "arn:"
- Ref: AWS::Partition
- :iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
Metadata:
aws:cdk:path: CdkHelloWorldStack/HelloWorldFunction/ServiceRole/Resource
HelloWorldFunctionunique-identifier:
Type: AWS::Lambda::Function
Properties:
Code:
S3Bucket:
Fn::Sub: cdk-unique-identifier-assets-${AWS::AccountId}-${AWS::Region}
S3Key: unique-identifier.zip
Handler: hello.handler
Role:
Fn::GetAtt:
- HelloWorldFunctionServiceRoleunique-identifier
- Arn
Runtime: nodejs20.x
DependsOn:
- HelloWorldFunctionServiceRoleunique-identifier
Metadata:
aws:cdk:path: CdkHelloWorldStack/HelloWorldFunction/Resource
aws:asset:path: asset.unique-identifier
aws:asset:is-bundled: false
aws:asset:property: Code
HelloWorldApiunique-identifier:
Type: AWS::ApiGateway::RestApi
Properties:
Name: HelloWorldApi
Metadata:
aws:cdk:path: CdkHelloWorldStack/HelloWorldApi/Resource
HelloWorldApiDeploymentunique-identifier:
Type: AWS::ApiGateway::Deployment
Properties:
Description: Automatically created by the RestApi construct
RestApiId:
Ref: HelloWorldApiunique-identifier
DependsOn:
- HelloWorldApihelloGETunique-identifier
- HelloWorldApihellounique-identifier
Metadata:
aws:cdk:path: CdkHelloWorldStack/HelloWorldApi/Deployment/Resource
HelloWorldApiDeploymentStageprod012345ABC:
Type: AWS::ApiGateway::Stage
Properties:
DeploymentId:
Ref: HelloWorldApiDeploymentunique-identifier
RestApiId:
Ref: HelloWorldApiunique-identifier
StageName: prod
Metadata:
aws:cdk:path: CdkHelloWorldStack/HelloWorldApi/DeploymentStage.prod/Resource
HelloWorldApihellounique-identifier:
Type: AWS::ApiGateway::Resource
Properties:
ParentId:
Fn::GetAtt:
- HelloWorldApiunique-identifier
- RootResourceId
PathPart: hello
RestApiId:
Ref: HelloWorldApiunique-identifier
Metadata:
aws:cdk:path: CdkHelloWorldStack/HelloWorldApi/Default/hello/Resource
HelloWorldApihelloGETApiPermissionCdkHelloWorldStackHelloWorldApiunique-identifier:
Type: AWS::Lambda::Permission
Properties:
Action: lambda:InvokeFunction
FunctionName:
Fn::GetAtt:
- HelloWorldFunctionunique-identifier
- Arn
Principal: apigateway.amazonaws.com
SourceArn:
Fn::Join:
- ""
- - "arn:"
- Ref: AWS::Partition
- ":execute-api:"
- Ref: AWS::Region
- ":"
- Ref: AWS::AccountId
- ":"
- Ref: HelloWorldApi9E278160
- /
- Ref: HelloWorldApiDeploymentStageprodunique-identifier
- /GET/hello
Metadata:
aws:cdk:path: CdkHelloWorldStack/HelloWorldApi/Default/hello/GET/ApiPermission.CdkHelloWorldStackHelloWorldApiunique-identifier.GET..hello
HelloWorldApihelloGETApiPermissionTestCdkHelloWorldStackHelloWorldApiunique-identifier:
Type: AWS::Lambda::Permission
Properties:
Action: lambda:InvokeFunction
FunctionName:
Fn::GetAtt:
- HelloWorldFunctionunique-identifier
- Arn
Principal: apigateway.amazonaws.com
SourceArn:
Fn::Join:
- ""
- - "arn:"
- Ref: AWS::Partition
- ":execute-api:"
- Ref: AWS::Region
- ":"
- Ref: AWS::AccountId
- ":"
- Ref: HelloWorldApiunique-identifier
- /test-invoke-stage/GET/hello
Metadata:
aws:cdk:path: CdkHelloWorldStack/HelloWorldApi/Default/hello/GET/ApiPermission.Test.CdkHelloWorldStackHelloWorldApiunique-identifier.GET..hello
HelloWorldApihelloGETunique-identifier:
Type: AWS::ApiGateway::Method
Properties:
AuthorizationType: NONE
HttpMethod: GET
Integration:
IntegrationHttpMethod: POST
Type: AWS_PROXY
Uri:
Fn::Join:
- ""
- - "arn:"
- Ref: AWS::Partition
- ":apigateway:"
- Ref: AWS::Region
- :lambda:path/2015-03-31/functions/
- Fn::GetAtt:
- HelloWorldFunctionunique-identifier
- Arn
- /invocations
ResourceId:
Ref: HelloWorldApihellounique-identifier
RestApiId:
Ref: HelloWorldApiunique-identifier
Metadata:
aws:cdk:path: CdkHelloWorldStack/HelloWorldApi/Default/hello/GET/Resource
CDKMetadata:
Type: AWS::CDK::Metadata
Properties:
Analytics: v2:deflate64:unique-identifier
Metadata:
aws:cdk:path: CdkHelloWorldStack/CDKMetadata/Default
Condition: CDKMetadataAvailable
Outputs:
HelloWorldApiEndpointunique-identifier:
Value:
Fn::Join:
- ""
- - https://
- Ref: HelloWorldApiunique-identifier
- .execute-api.
- Ref: AWS::Region
- "."
- Ref: AWS::URLSuffix
- /
- Ref: HelloWorldApiDeploymentStageprodunique-identifier
- /
Conditions:
CDKMetadataAvailable:
Fn::Or:
- Fn::Or:
- Fn::Equals:
- Ref: AWS::Region
- af-south-1
- Fn::Equals:
- Ref: AWS::Region
- ap-east-1
- Fn::Equals:
- Ref: AWS::Region
- ap-northeast-1
- Fn::Equals:
- Ref: AWS::Region
- ap-northeast-2
- Fn::Equals:
- Ref: AWS::Region
- ap-south-1
- Fn::Equals:
- Ref: AWS::Region
- ap-southeast-1
- Fn::Equals:
- Ref: AWS::Region
- ap-southeast-2
- Fn::Equals:
- Ref: AWS::Region
- ca-central-1
- Fn::Equals:
- Ref: AWS::Region
- cn-north-1
- Fn::Equals:
- Ref: AWS::Region
- cn-northwest-1
- Fn::Or:
- Fn::Equals:
- Ref: AWS::Region
- eu-central-1
- Fn::Equals:
- Ref: AWS::Region
- eu-north-1
- Fn::Equals:
- Ref: AWS::Region
- eu-south-1
- Fn::Equals:
- Ref: AWS::Region
- eu-west-1
- Fn::Equals:
- Ref: AWS::Region
- eu-west-2
- Fn::Equals:
- Ref: AWS::Region
- eu-west-3
- Fn::Equals:
- Ref: AWS::Region
- il-central-1
- Fn::Equals:
- Ref: AWS::Region
- me-central-1
- Fn::Equals:
- Ref: AWS::Region
- me-south-1
- Fn::Equals:
- Ref: AWS::Region
- sa-east-1
- Fn::Or:
- Fn::Equals:
- Ref: AWS::Region
- us-east-1
- Fn::Equals:
- Ref: AWS::Region
- us-east-2
- Fn::Equals:
- Ref: AWS::Region
- us-west-1
- Fn::Equals:
- Ref: AWS::Region
- us-west-2
Parameters:
BootstrapVersion:
Type: AWS::SSM::Parameter::Value
Default: /cdk-bootstrap/hnb659fds/version
Description: Version of the CDK Bootstrap resources in this environment, automatically retrieved from SSM Parameter Store. [cdk:skip]
Rules:
CheckBootstrapVersion:
Assertions:
- Assert:
Fn::Not:
- Fn::Contains:
- - "1"
- "2"
- "3"
- "4"
- "5"
- Ref: BootstrapVersion
AssertDescription: CDK bootstrap stack version 6 required. Please run 'cdk bootstrap' with a recent version of the CDK CLI.
```
Dengan menggunakan konstruksi L2, Anda mendefinisikan beberapa properti untuk mengonfigurasi sumber daya Anda dan menggunakan metode pembantu untuk mengintegrasikannya bersama-sama. AWS CDK mengonfigurasi sebagian besar AWS CloudFormation sumber daya dan properti yang diperlukan untuk menyediakan aplikasi Anda.
## Langkah 5: Menerapkan aplikasi Anda
Pada langkah ini, Anda menggunakan perintah AWS CDK `cdk deploy` CLI untuk menyebarkan aplikasi Anda. AWS CDK bekerja dengan AWS CloudFormation layanan untuk menyediakan sumber daya Anda.
**penting**
Anda harus melakukan bootstrap satu kali dari lingkungan Anda AWS sebelum penerapan. Untuk petunjuk, lihat [Bootstrap lingkungan Anda untuk digunakan dengan AWS CDK](bootstrapping-env.md).
Dari akar proyek Anda, jalankan yang berikut ini. Konfirmasikan perubahan jika diminta:
```
$ cdk deploy
✨ Synthesis time: 2.44s
...
Do you wish to deploy these changes (y/n)?
```
Saat penerapan selesai, AWS CDK CLI akan menampilkan URL titik akhir Anda. Salin URL ini untuk langkah selanjutnya. Berikut ini adalah contohnya:
```
...
✅ HelloWorldStack
✨ Deployment time: 45.37s
Outputs:
HelloWorldStack.HelloWorldApiEndpointunique-identifier = https://.execute-api..amazonaws.com/prod/
Stack ARN:
arn:aws:cloudformation:region:account-id:stack/HelloWorldStack/unique-identifier
...
```
## Langkah 6: Berinteraksi dengan aplikasi Anda
Pada langkah ini, Anda memulai permintaan GET ke titik akhir API Anda dan menerima respons fungsi Lambda Anda.
Temukan URL titik akhir Anda dari langkah sebelumnya dan tambahkan `/hello` jalurnya. Kemudian, menggunakan browser atau command prompt Anda, kirim permintaan GET ke titik akhir Anda. Berikut ini adalah contohnya:
```
$ curl https://.execute-api..amazonaws.com/prod/hello
{"message":"Hello World!"}%
```
Selamat, Anda telah berhasil membuat, menyebarkan, dan berinteraksi dengan aplikasi Anda menggunakan CDK\$1 AWS
## Langkah 7: Hapus aplikasi Anda
Pada langkah ini, Anda menggunakan AWS CDK CLI untuk menghapus aplikasi Anda dari AWS Cloud.
Untuk menghapus aplikasi Anda, jalankan`cdk destroy`. Saat diminta, konfirmasikan permintaan Anda untuk menghapus aplikasi:
```
$ cdk destroy
Are you sure you want to delete: CdkHelloWorldStack (y/n)? y
CdkHelloWorldStack: destroying... [1/1]
...
✅ CdkHelloWorldStack: destroyed
```
## Penyelesaian Masalah
### Kesalahan: \$1"message”: “Kesalahan server internal"\$1%
Saat menjalankan fungsi Lambda yang diterapkan, Anda menerima kesalahan ini. Kesalahan ini dapat terjadi karena berbagai alasan.
**Untuk memecahkan masalah lebih lanjut**
Gunakan AWS CLI untuk menjalankan fungsi Lambda Anda.
1. Ubah file tumpukan Anda untuk menangkap nilai output dari nama fungsi Lambda yang Anda gunakan. Berikut ini adalah contohnya:
```
...
class CdkHelloWorldStack extends Stack {
constructor(scope, id, props) {
super(scope, id, props);
// Define the Lambda function resource
// ...
new CfnOutput(this, 'HelloWorldFunctionName', {
value: helloWorldFunction.functionName,
description: 'JavaScript Lambda function'
});
// Define the API Gateway resource
// ...
}
}
```
1. Terapkan aplikasi Anda lagi. AWS CDK CLI akan menampilkan nilai nama fungsi Lambda yang Anda gunakan:
```
$ cdk deploy
✨ Synthesis time: 0.29s
...
✅ CdkHelloWorldStack
✨ Deployment time: 20.36s
Outputs:
...
CdkHelloWorldStack.HelloWorldFunctionName = CdkHelloWorldStack-HelloWorldFunctionunique-identifier
...
```
1. Gunakan AWS CLI untuk menjalankan fungsi Lambda Anda di AWS Cloud dan menampilkan respons ke file teks:
```
$ aws lambda invoke --function-name CdkHelloWorldStack-HelloWorldFunctionunique-identifier output.txt
```
1. Periksa `output.txt` untuk melihat hasil Anda.
**Kemungkinan penyebabnya: Sumber daya API Gateway didefinisikan secara tidak benar di file tumpukan Anda**
Jika `output.txt` menunjukkan respons fungsi Lambda yang berhasil, masalahnya mungkin terkait dengan cara Anda mendefinisikan API REST API Gateway API Anda. AWS CLI memanggil Lambda Anda secara langsung, bukan melalui titik akhir Anda. Periksa kode Anda untuk memastikannya cocok dengan tutorial ini. Kemudian, gunakan lagi.
**Kemungkinan penyebabnya: Sumber daya Lambda didefinisikan secara tidak benar di file tumpukan Anda**
Jika `output.txt` mengembalikan kesalahan, masalahnya mungkin dengan cara Anda mendefinisikan fungsi Lambda Anda. Periksa kode Anda untuk memastikannya cocok dengan tutorial ini. Kemudian gunakan lagi.