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 AWS CDK pertama Anda
Mulailah menggunakan AWS Cloud Development Kit (AWS CDK) dengan menggunakan AWS CDK Command Line Interface (AWS CDK CLI) untuk mengembangkan aplikasi CDK pertama Anda, bootstrap lingkungan AWS Anda, dan menerapkan aplikasi Anda. AWS
## Prasyarat
Sebelum memulai tutorial ini, selesaikan semua langkah pengaturan di [Memulai dengan AWS CDK](getting-started.md).
## Tentang tutorial ini
Dalam tutorial ini, Anda akan membuat dan menyebarkan aplikasi sederhana AWS menggunakan AWS CDK. Aplikasi ini terdiri dari [fungsi AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/welcome.html) yang mengembalikan `Hello World!` pesan saat dipanggil. Fungsi ini akan dipanggil melalui URL fungsi [Lambda yang berfungsi sebagai titik akhir HTTP (S) khusus untuk fungsi](https://docs.aws.amazon.com/lambda/latest/dg/lambda-urls.html) Lambda Anda.
Melalui tutorial ini, Anda akan melakukan hal berikut:
+ **Buat proyek Anda** - Buat proyek CDK menggunakan perintah CDK CLI. `cdk init`
+ **Konfigurasikan AWS lingkungan Anda** — Konfigurasikan AWS lingkungan tempat Anda akan menerapkan aplikasi Anda.
+ **Bootstrap AWS lingkungan Anda** - Persiapkan AWS lingkungan Anda untuk penerapan dengan mem-bootstrapping menggunakan perintah CDK CLI. `cdk bootstrap`
+ **Kembangkan aplikasi Anda** — Gunakan konstruksi dari AWS Construct Library untuk menentukan fungsi Lambda dan resource URL fungsi Lambda Anda.
+ **Mempersiapkan aplikasi Anda untuk penerapan** — Gunakan CDK CLI untuk membangun aplikasi Anda dan mensintesis template. AWS CloudFormation
+ **Menerapkan aplikasi Anda** — Gunakan `cdk deploy` perintah CDK CLI untuk menerapkan aplikasi Anda dan menyediakan sumber daya Anda. AWS
+ **Berinteraksi dengan aplikasi Anda** — Berinteraksi dengan fungsi Lambda yang Anda gunakan dengan AWS memanggilnya dan menerima respons.
+ **Ubah aplikasi Anda** — Ubah fungsi Lambda Anda dan terapkan untuk mengimplementasikan perubahan Anda.
+ **Hapus aplikasi Anda** — Hapus semua sumber daya yang Anda buat dengan menggunakan perintah CDK `cdk destroy` CLI.
## Langkah 1: Buat proyek CDK Anda
Pada langkah ini, Anda membuat proyek CDK baru. Proyek CDK harus berada di direktorinya sendiri, dengan dependensi modul lokalnya sendiri.
**Untuk membuat proyek CDK**
1. Dari direktori awal pilihan Anda, buat dan navigasikan ke direktori bernama`hello-cdk`:
```
$ mkdir hello-cdk && cd hello-cdk
```
**penting**
Pastikan untuk memberi nama direktori proyek Anda`hello-cdk`, *persis seperti yang ditunjukkan di sini*. CDK CLI menggunakan nama direktori ini untuk memberi nama hal-hal dalam kode CDK Anda. Jika Anda menggunakan nama direktori yang berbeda, Anda akan mengalami masalah selama tutorial ini.
1. Dari `hello-cdk` direktori, inisialisasi proyek CDK baru menggunakan perintah CDK CLI`cdk init`. Tentukan `app` template dan bahasa pemrograman pilihan Anda dengan `--language` opsi:
**Example**
------
#### [ TypeScript ]
```
$ cdk init app --language typescript
```
------
#### [ JavaScript ]
```
$ cdk init app --language javascript
```
------
#### [ Python ]
```
$ cdk init app --language python
```
Setelah aplikasi dibuat, masukkan juga dua perintah berikut. Ini mengaktifkan lingkungan virtual Python aplikasi dan menginstal dependensi inti AWS CDK.
```
$ source .venv/bin/activate # On Windows, run `.\venv\Scripts\activate` instead
$ python -m pip install -r requirements.txt
```
------
#### [ Java ]
```
$ cdk init app --language java
```
Jika Anda menggunakan IDE, Anda sekarang dapat membuka atau mengimpor proyek. DalamEclipse, misalnya, pilih **File** > **Import** > Maven > **Existing Maven** **Projects**. Pastikan bahwa pengaturan proyek diatur untuk menggunakan Java 8 (1.8).
------
#### [ C\$1 ]
```
$ cdk init app --language csharp
```
Jika Anda menggunakan Visual Studio, buka file solusi di `src` direktori.
------
#### [ Go ]
```
$ cdk init app --language go
```
Setelah aplikasi dibuat, masukkan juga perintah berikut untuk menginstal modul AWS Construct Library yang dibutuhkan aplikasi.
```
$ go get
```
------
`cdk init`Perintah membuat struktur file dan folder dalam `hello-cdk` direktori untuk membantu mengatur kode sumber untuk aplikasi CDK Anda. Struktur file dan folder ini disebut *proyek* CDK Anda. Luangkan waktu sejenak untuk menjelajahi proyek CDK Anda.
Jika Anda telah Git menginstal, setiap proyek yang Anda buat menggunakan juga `cdk init` diinisialisasi sebagai Git repositori.
Selama inisialisasi proyek, CDK CLI membuat aplikasi CDK yang berisi satu tumpukan CDK. Instance aplikasi CDK dibuat menggunakan [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.App.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.App.html)konstruksi. Berikut ini adalah bagian dari kode ini dari file aplikasi CDK Anda:
**Example**
Terletak di`bin/hello-cdk.ts`:
```
#!/usr/bin/env node
import 'source-map-support/register';
import * as cdk from 'aws-cdk-lib';
import { HelloCdkStack } from '../lib/hello-cdk-stack';
const app = new cdk.App();
new HelloCdkStack(app, 'HelloCdkStack', {
});
```
Terletak di`bin/hello-cdk.js`:
```
#!/usr/bin/env node
const cdk = require('aws-cdk-lib');
const { HelloCdkStack } = require('../lib/hello-cdk-stack');
const app = new cdk.App();
new HelloCdkStack(app, 'HelloCdkStack', {
});
```
Terletak di`app.py`:
```
#!/usr/bin/env python3
import os
import aws_cdk as cdk
from hello_cdk.hello_cdk_stack import HelloCdkStack
app = cdk.App()
HelloCdkStack(app, "HelloCdkStack",)
app.synth()
```
Terletak di`src/main/java/…/HelloCdkApp.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 HelloCdkApp {
public static void main(final String[] args) {
App app = new App();
new HelloCdkStack(app, "HelloCdkStack", StackProps.builder()
.build());
app.synth();
}
}
```
Terletak di`src/HelloCdk/Program.cs`:
```
using Amazon.CDK;
using System;
using System.Collections.Generic;
using System.Linq;
namespace HelloCdk
{
sealed class Program
{
public static void Main(string[] args)
{
var app = new App();
new HelloCdkStack(app, "HelloCdkStack", new StackProps
{});
app.Synth();
}
}
}
```
Terletak di`hello-cdk.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)
NewHelloCdkStack(app, "HelloCdkStack", &HelloCdkStackProps{
awscdk.StackProps{
Env: env(),
},
})
app.Synth(nil)
}
// ...
```
Tumpukan CDK dibuat menggunakan [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Stack.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.Stack.html)konstruksi. Berikut ini adalah bagian dari kode ini dari file tumpukan CDK Anda:
**Example**
Terletak di`lib/hello-cdk-stack.ts`:
```
import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
export class HelloCdkStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Define your constructs here
}
}
```
Terletak di`lib/hello-cdk-stack.js`:
```
const { Stack } = require('aws-cdk-lib');
class HelloCdkStack extends Stack {
constructor(scope, id, props) {
super(scope, id, props);
// Define your constructs here
}
}
module.exports = { HelloCdkStack }
```
Terletak di`hello_cdk/hello_cdk_stack.py`:
```
from aws_cdk import (
Stack,
)
from constructs import Construct
class HelloCdkStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# Define your constructs here
```
Terletak di`src/main/java/…/HelloCdkStack.java`:
```
package com.myorg;
import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;
public class HelloCdkStack extends Stack {
public HelloCdkStack(final Construct scope, final String id) {
this(scope, id, null);
}
public HelloCdkStack(final Construct scope, final String id, final StackProps props) {
super(scope, id, props);
// Define your constructs here
}
}
```
Terletak di`src/HelloCdk/HelloCdkStack.cs`:
```
using Amazon.CDK;
using Constructs;
namespace HelloCdk
{
public class HelloCdkStack : Stack
{
internal HelloCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
// Define your constructs here
}
}
}
```
Terletak di`hello-cdk.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 HelloCdkStackProps struct {
awscdk.StackProps
}
func NewHelloCdkStack(scope constructs.Construct, id string, props *HelloCdkStackProps) awscdk.Stack {
var sprops awscdk.StackProps
if props != nil {
sprops = props.StackProps
}
stack := awscdk.NewStack(scope, &id, &sprops)
return stack
}
// ...
```
## Langkah 2: Konfigurasikan AWS lingkungan Anda
Pada langkah ini, Anda mengonfigurasi AWS lingkungan untuk tumpukan CDK Anda. Dengan melakukan ini, Anda menentukan lingkungan mana tumpukan CDK Anda akan digunakan.
Pertama, tentukan AWS lingkungan yang ingin Anda gunakan. AWS Lingkungan terdiri dari AWS akun dan AWS Wilayah.
Ketika Anda menggunakan AWS CLI untuk mengonfigurasi kredensi keamanan pada mesin lokal Anda, Anda kemudian dapat menggunakan AWS CLI untuk mendapatkan informasi AWS lingkungan untuk profil tertentu.
**Untuk menggunakan AWS CLI untuk mendapatkan ID akun Anda AWS **
1. Jalankan perintah AWS CLI berikut untuk mendapatkan ID AWS akun untuk profil Anda`default`:
```
$ aws sts get-caller-identity --query "Account" --output text
```
1. Jika Anda lebih suka menggunakan profil bernama, berikan nama profil Anda menggunakan `--profile` opsi:
```
$ aws sts get-caller-identity --profile your-profile-name --query "Account" --output text
```
**Untuk menggunakan AWS CLI untuk mendapatkan Wilayah Anda AWS **
1. Jalankan perintah AWS CLI berikut untuk mendapatkan Wilayah yang Anda konfigurasikan untuk profil Anda`default`:
```
$ aws configure get region
```
1. Jika Anda lebih suka menggunakan profil bernama, berikan nama profil Anda menggunakan `--profile` opsi:
```
$ aws configure get region --profile your-profile-name
```
Selanjutnya, Anda akan mengonfigurasi AWS lingkungan untuk tumpukan CDK Anda dengan memodifikasi `HelloCdkStack` instance di file *aplikasi* Anda. Untuk tutorial ini, Anda akan membuat kode keras informasi AWS lingkungan Anda. Ini tidak disarankan untuk lingkungan produksi. Untuk informasi tentang cara lain mengonfigurasi lingkungan, lihat [Mengonfigurasi lingkungan yang akan digunakan dengan AWS CDK](configure-env.md).
**Untuk mengonfigurasi lingkungan untuk tumpukan CDK Anda**
1. Dalam *file aplikasi* Anda, gunakan `env` properti `Stack` konstruksi untuk mengkonfigurasi lingkungan Anda. Berikut ini adalah contohnya:
**Example**
------
#### [ TypeScript ]
Terletak di`bin/hello-cdk.ts`:
```
#!/usr/bin/env node
import 'source-map-support/register';
import * as cdk from 'aws-cdk-lib';
import { HelloCdkStack } from '../lib/hello-cdk-stack';
const app = new cdk.App();
new HelloCdkStack(app, 'HelloCdkStack', {
env: { account: '123456789012', region: 'us-east-1' },
});
```
------
#### [ JavaScript ]
Terletak di`bin/hello-cdk.js`:
```
#!/usr/bin/env node
const cdk = require('aws-cdk-lib');
const { HelloCdkStack } = require('../lib/hello-cdk-stack');
const app = new cdk.App();
new HelloCdkStack(app, 'HelloCdkStack', {
env: { account: '123456789012', region: 'us-east-1' },
});
```
------
#### [ Python ]
Terletak di`app.py`:
```
#!/usr/bin/env python3
import os
import aws_cdk as cdk
from hello_cdk.hello_cdk_stack import HelloCdkStack
app = cdk.App()
HelloCdkStack(app, "HelloCdkStack",
env=cdk.Environment(account='123456789012', region='us-east-1'),
)
app.synth()
```
------
#### [ Java ]
Terletak di`src/main/java/…/HelloCdkApp.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 HelloCdkApp {
public static void main(final String[] args) {
App app = new App();
new HelloCdkStack(app, "HelloCdkStack", StackProps.builder()
.env(Environment.builder()
.account("123456789012")
.region("us-east-1")
.build())
.build());
app.synth();
}
}
```
------
#### [ C\$1 ]
Terletak di`src/HelloCdk/Program.cs`:
```
using Amazon.CDK;
using System;
using System.Collections.Generic;
using System.Linq;
namespace HelloCdk
{
sealed class Program
{
public static void Main(string[] args)
{
var app = new App();
new HelloCdkStack(app, "HelloCdkStack", new StackProps
{
Env = new Amazon.CDK.Environment
{
Account = "123456789012",
Region = "us-east-1",
}
});
app.Synth();
}
}
}
```
------
#### [ Go ]
Terletak di`hello-cdk.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)
NewHelloCdkStack(app, "HelloCdkStack", &HelloCdkStackProps{
awscdk.StackProps{
Env: env(),
},
})
app.Synth(nil)
}
func env() *awscdk.Environment {
return &awscdk.Environment{
Account: jsii.String("123456789012"),
Region: jsii.String("us-east-1"),
}
}
```
------
## Langkah 3: Bootstrap AWS lingkungan Anda
Pada langkah ini, Anda mem-bootstrap AWS lingkungan yang Anda konfigurasikan pada langkah sebelumnya. Ini mempersiapkan lingkungan Anda untuk penerapan CDK.
Untuk mem-bootstrap lingkungan Anda, jalankan yang berikut ini dari root proyek CDK Anda:
```
$ cdk bootstrap
```
Dengan melakukan bootstrap dari root proyek CDK Anda, Anda tidak perlu memberikan informasi tambahan apa pun. CDK CLI memperoleh informasi lingkungan dari proyek Anda. Ketika Anda bootstrap di luar proyek CDK, Anda harus memberikan informasi lingkungan dengan `cdk bootstrap` perintah. Untuk informasi selengkapnya, lihat [Bootstrap lingkungan Anda untuk digunakan dengan AWS CDK](bootstrapping-env.md).
## Langkah 4: Bangun aplikasi CDK Anda
Di sebagian besar lingkungan pemrograman, Anda membangun atau mengkompilasi kode setelah melakukan perubahan. Ini tidak diperlukan dengan AWS CDK karena CDK CLI akan secara otomatis melakukan langkah ini. Namun, Anda masih dapat membangun secara manual ketika Anda ingin menangkap kesalahan sintaks dan mengetik. Berikut ini adalah contohnya:
**Example**
```
$ npm run build
> hello-cdk@0.1.0 build
> tsc
```
Tidak ada langkah membangun yang diperlukan.
Tidak ada langkah membangun yang diperlukan.
```
$ mvn compile -q
```
Atau tekan `Control-B` di Eclipse (Jawa lain IDEs mungkin berbeda)
```
$ dotnet build src
```
Atau tekan F6 di Visual Studio
```
$ go build
```
## Langkah 5: Buat daftar tumpukan CDK di aplikasi
Pada titik ini, Anda harus memiliki aplikasi CDK yang berisi satu tumpukan CDK. Untuk memverifikasi, gunakan perintah CDK `cdk list` CLI untuk menampilkan tumpukan Anda. Output harus menampilkan tumpukan tunggal bernama`HelloCdkStack`:
```
$ cdk list
HelloCdkStack
```
Jika Anda tidak melihat output ini, verifikasi bahwa Anda berada di direktori kerja yang benar dari proyek Anda dan coba lagi. Jika Anda masih tidak melihat tumpukan Anda, ulangi [Langkah 1: Buat proyek CDK Anda](#hello-world-create) dan coba lagi.
## Langkah 6: Tentukan fungsi Lambda Anda
Pada langkah ini, Anda mengimpor [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html)modul dari AWS Construct Library dan menggunakan konstruksi [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.Function.html)L2.
Ubah file tumpukan CDK Anda sebagai berikut:
**Example**
Terletak di`lib/hello-cdk-stack.ts`:
```
import * as cdk from 'aws-cdk-lib';
import { Construct } from 'constructs';
// Import the Lambda module
import * as lambda from 'aws-cdk-lib/aws-lambda';
export class HelloCdkStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Define the Lambda function resource
const myFunction = new lambda.Function(this, "HelloWorldFunction", {
runtime: lambda.Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
handler: "index.handler",
code: lambda.Code.fromInline(`
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello World!'),
};
};
`),
});
}
}
```
Terletak di`lib/hello-cdk-stack.js`:
```
const { Stack } = require('aws-cdk-lib');
// Import the Lambda module
const lambda = require('aws-cdk-lib/aws-lambda');
class HelloCdkStack extends Stack {
constructor(scope, id, props) {
super(scope, id, props);
// Define the Lambda function resource
const myFunction = new lambda.Function(this, "HelloWorldFunction", {
runtime: lambda.Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
handler: "index.handler",
code: lambda.Code.fromInline(`
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello World!'),
};
};
`),
});
}
}
module.exports = { HelloCdkStack }
```
Terletak di`hello_cdk/hello_cdk_stack.py`:
```
from aws_cdk import (
Stack,
aws_lambda as _lambda, # Import the Lambda module
)
from constructs import Construct
class HelloCdkStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# Define the Lambda function resource
my_function = _lambda.Function(
self, "HelloWorldFunction",
runtime = _lambda.Runtime.NODEJS_20_X, # Provide any supported Node.js runtime
handler = "index.handler",
code = _lambda.Code.from_inline(
"""
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello World!'),
};
};
"""
),
)
```
Terletak di`src/main/java/…/HelloCdkStack.java`:
```
package com.myorg;
import software.constructs.Construct;
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.StackProps;
// Import Lambda function
import software.amazon.awscdk.services.lambda.Code;
import software.amazon.awscdk.services.lambda.Function;
import software.amazon.awscdk.services.lambda.Runtime;
public class HelloCdkStack extends Stack {
public HelloCdkStack(final Construct scope, final String id) {
this(scope, id, null);
}
public HelloCdkStack(final Construct scope, final String id, final StackProps props) {
super(scope, id, props);
// Define the Lambda function resource
Function myFunction = Function.Builder.create(this, "HelloWorldFunction")
.runtime(Runtime.NODEJS_20_X) // Provide any supported Node.js runtime
.handler("index.handler")
.code(Code.fromInline(
"exports.handler = async function(event) {" +
" return {" +
" statusCode: 200," +
" body: JSON.stringify('Hello World!')" +
" };" +
"};"))
.build();
}
}
```
Terletak di`src/main/java/…/HelloCdkStack.java`:
```
using Amazon.CDK;
using Constructs;
// Import the Lambda module
using Amazon.CDK.AWS.Lambda;
namespace HelloCdk
{
public class HelloCdkStack : Stack
{
internal HelloCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
// Define the Lambda function resource
var myFunction = new Function(this, "HelloWorldFunction", new FunctionProps
{
Runtime = Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
Handler = "index.handler",
Code = Code.FromInline(@"
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello World!'),
};
};
"),
});
}
}
}
```
Terletak di`hello-cdk.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"
// Import the Lambda module
"github.com/aws/aws-cdk-go/awscdk/v2/awslambda"
)
type HelloCdkStackProps struct {
awscdk.StackProps
}
func NewHelloCdkStack(scope constructs.Construct, id string, props *HelloCdkStackProps) awscdk.Stack {
var sprops awscdk.StackProps
if props != nil {
sprops = props.StackProps
}
stack := awscdk.NewStack(scope, &id, &sprops)
// Define the Lambda function resource
myFunction := awslambda.NewFunction(stack, jsii.String("HelloWorldFunction"), &awslambda.FunctionProps{
Runtime: awslambda.Runtime_NODEJS_20_X(), // Provide any supported Node.js runtime
Handler: jsii.String("index.handler"),
Code: awslambda.Code_FromInline(jsii.String(`
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello World!'),
};
};
`)),
})
return stack
}
// ...
```
Mari kita lihat lebih dekat `Function` konstruksinya. Seperti semua konstruksi, `Function` kelas mengambil tiga parameter:
+ **scope** — Mendefinisikan `Stack` instance Anda sebagai induk dari `Function` konstruksi. Semua konstruksi yang mendefinisikan AWS sumber daya dibuat dalam lingkup tumpukan. Anda dapat menentukan konstruksi di dalam konstruksi, membuat hierarki (pohon). Di sini, dan dalam banyak kasus, cakupannya adalah `this` (`self`dalam Python).
+ **Id** — ID build dari `Function` dalam aplikasi AWS CDK Anda. ID ini, ditambah hash berdasarkan lokasi fungsi di dalam tumpukan, secara unik mengidentifikasi fungsi selama penerapan. AWS CDK juga mereferensikan ID ini saat Anda memperbarui konstruksi di aplikasi dan menerapkan ulang untuk memperbarui sumber daya yang diterapkan. Di sini, ID konstruksi Anda adalah`HelloWorldFunction`. Fungsi juga dapat memiliki nama, ditentukan dengan `functionName` properti. Ini berbeda dengan ID konstruksi.
+ **props** — Sebuah bundel nilai yang mendefinisikan properti dari fungsi. Di sini Anda mendefinisikan`runtime`,`handler`, dan `code` properti.
Alat peraga diwakili secara berbeda dalam bahasa yang didukung oleh AWS CDK.
+ Dalam TypeScript dan JavaScript, `props` adalah argumen tunggal dan Anda meneruskan objek yang berisi properti yang diinginkan.
+ Dalam Python, props dilewatkan sebagai argumen kata kunci.
+ Di Jawa, Builder disediakan untuk melewati alat peraga. Ada dua: satu untuk`FunctionProps`, dan yang kedua `Function` untuk membiarkan Anda membangun konstruksi dan objek alat peraga dalam satu langkah. Kode ini menggunakan yang terakhir.
+ Di C \$1, Anda membuat instance `FunctionProps` objek menggunakan penginisialisasi objek dan meneruskannya sebagai parameter ketiga.
Jika alat peraga konstruksi bersifat opsional, Anda dapat menghilangkan parameter sepenuhnya. `props`
Semua konstruksi mengambil tiga argumen yang sama ini, jadi mudah untuk tetap berorientasi saat Anda belajar tentang yang baru. Dan seperti yang Anda duga, Anda dapat mensubkelas konstruksi apa pun untuk memperluasnya sesuai dengan kebutuhan Anda, atau jika Anda ingin mengubah defaultnya.
## Langkah 7: Tentukan URL fungsi Lambda Anda
Pada langkah ini, Anda menggunakan metode `addFunctionUrl` pembantu `Function` konstruksi untuk menentukan URL fungsi Lambda. Untuk menampilkan nilai URL ini saat penerapan, Anda akan membuat AWS CloudFormation output menggunakan [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.CfnOutput.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.CfnOutput.html)konstruksi.
Tambahkan yang berikut ini ke file tumpukan CDK Anda:
**Example**
Terletak di`lib/hello-cdk-stack.ts`:
```
// ...
export class HelloCdkStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Define the Lambda function resource
// ...
// Define the Lambda function URL resource
const myFunctionUrl = myFunction.addFunctionUrl({
authType: lambda.FunctionUrlAuthType.NONE,
});
// Define a CloudFormation output for your URL
new cdk.CfnOutput(this, "myFunctionUrlOutput", {
value: myFunctionUrl.url,
})
}
}
```
Terletak di`lib/hello-cdk-stack.js`:
```
const { Stack, CfnOutput } = require('aws-cdk-lib'); // Import CfnOutput
class HelloCdkStack extends Stack {
constructor(scope, id, props) {
super(scope, id, props);
// Define the Lambda function resource
// ...
// Define the Lambda function URL resource
const myFunctionUrl = myFunction.addFunctionUrl({
authType: lambda.FunctionUrlAuthType.NONE,
});
// Define a CloudFormation output for your URL
new CfnOutput(this, "myFunctionUrlOutput", {
value: myFunctionUrl.url,
})
}
}
module.exports = { HelloCdkStack }
```
Terletak di`hello_cdk/hello_cdk_stack.py`:
```
from aws_cdk import (
# ...
CfnOutput # Import CfnOutput
)
from constructs import Construct
class HelloCdkStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# Define the Lambda function resource
# ...
# Define the Lambda function URL resource
my_function_url = my_function.add_function_url(
auth_type = _lambda.FunctionUrlAuthType.NONE,
)
# Define a CloudFormation output for your URL
CfnOutput(self, "myFunctionUrlOutput", value=my_function_url.url)
```
Terletak di`src/main/java/…/HelloCdkStack.java`:
```
package com.myorg;
// ...
// Import Lambda function URL
import software.amazon.awscdk.services.lambda.FunctionUrl;
import software.amazon.awscdk.services.lambda.FunctionUrlAuthType;
import software.amazon.awscdk.services.lambda.FunctionUrlOptions;
// Import CfnOutput
import software.amazon.awscdk.CfnOutput;
public class HelloCdkStack extends Stack {
public HelloCdkStack(final Construct scope, final String id) {
this(scope, id, null);
}
public HelloCdkStack(final Construct scope, final String id, final StackProps props) {
super(scope, id, props);
// Define the Lambda function resource
// ...
// Define the Lambda function URL resource
FunctionUrl myFunctionUrl = myFunction.addFunctionUrl(FunctionUrlOptions.builder()
.authType(FunctionUrlAuthType.NONE)
.build());
// Define a CloudFormation output for your URL
CfnOutput.Builder.create(this, "myFunctionUrlOutput")
.value(myFunctionUrl.getUrl())
.build();
}
}
```
Terletak di`src/main/java/…/HelloCdkStack.java`:
```
// ...
namespace HelloCdk
{
public class HelloCdkStack : Stack
{
internal HelloCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
// Define the Lambda function resource
// ...
// Define the Lambda function URL resource
var myFunctionUrl = myFunction.AddFunctionUrl(new FunctionUrlOptions
{
AuthType = FunctionUrlAuthType.NONE
});
// Define a CloudFormation output for your URL
new CfnOutput(this, "myFunctionUrlOutput", new CfnOutputProps
{
Value = myFunctionUrl.Url
});
}
}
}
```
Terletak di`hello-cdk.go`:
```
// ...
func NewHelloCdkStack(scope constructs.Construct, id string, props *HelloCdkStackProps) 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 Lambda function URL resource
myFunctionUrl := myFunction.AddFunctionUrl(&awslambda.FunctionUrlOptions{
AuthType: awslambda.FunctionUrlAuthType_NONE,
})
// Define a CloudFormation output for your URL
awscdk.NewCfnOutput(stack, jsii.String("myFunctionUrlOutput"), &awscdk.CfnOutputProps{
Value: myFunctionUrl.Url(),
})
return stack
}
// ...
```
**Awas**
Agar tutorial ini tetap sederhana, URL fungsi Lambda Anda didefinisikan tanpa otentikasi. Saat digunakan, ini membuat titik akhir yang dapat diakses publik yang dapat digunakan untuk menjalankan fungsi Anda. Setelah selesai dengan tutorial ini, ikuti [Langkah 12: Hapus aplikasi Anda](#hello-world-delete) untuk menghapus sumber daya ini.
## Langkah 8: Sintesis template CloudFormation
Pada langkah ini, Anda mempersiapkan penerapan dengan mensintesis CloudFormation template dengan perintah CDK CLI. `cdk synth` Perintah ini melakukan validasi dasar kode CDK Anda, menjalankan aplikasi CDK Anda, dan menghasilkan CloudFormation template dari tumpukan CDK Anda.
Jika aplikasi berisi lebih dari satu tumpukan, Anda harus menentukan tumpukan mana yang akan disintesis. Karena aplikasi Anda berisi satu tumpukan, CDK CLI secara otomatis mendeteksi tumpukan yang akan disintesis.
Jika Anda tidak mensintesis template, CDK CLI akan secara otomatis melakukan langkah ini saat Anda menerapkan. Namun, kami menyarankan Anda menjalankan langkah ini sebelum setiap penerapan untuk memeriksa kesalahan sintesis.
Sebelum mensintesis template, Anda dapat membuat aplikasi secara opsional untuk menangkap kesalahan sintaks dan mengetik. Untuk petunjuk, lihat [Langkah 4: Membangun aplikasi CDK Anda](#hello-world-build).
Untuk mensintesis CloudFormation template, jalankan yang berikut ini dari root proyek Anda:
```
$ cdk synth
```
**catatan**
Jika Anda menerima kesalahan seperti berikut ini, verifikasi bahwa Anda berada di `hello-cdk` direktori dan coba lagi:
```
--app is required either in command-line, in cdk.json or in ~/.cdk.json
```
Jika berhasil, CDK CLI akan menampilkan templat `YAML` yang CloudFormation diformat `stdout` —ke dan menyimpan `JSON` templat yang diformat —di direktori proyek Anda. `cdk.out`
Berikut ini adalah contoh output dari CloudFormation template:
### AWS CloudFormation template
```
Resources:
HelloWorldFunctionServiceRole:
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: HelloCdkStack/HelloWorldFunction/ServiceRole/Resource
HelloWorldFunction:
Type: AWS::Lambda::Function
Properties:
Code:
ZipFile: "
\ exports.handler = async function(event) {
\ return {
\ statusCode: 200,
\ body: JSON.stringify('Hello World!'),
\ };
\ };
\ "
Handler: index.handler
Role:
Fn::GetAtt:
- HelloWorldFunctionServiceRole
- Arn
Runtime: nodejs20.x
DependsOn:
- HelloWorldFunctionServiceRole
Metadata:
aws:cdk:path: HelloCdkStack/HelloWorldFunction/Resource
HelloWorldFunctionFunctionUrl:
Type: AWS::Lambda::Url
Properties:
AuthType: NONE
TargetFunctionArn:
Fn::GetAtt:
- HelloWorldFunction
- Arn
Metadata:
aws:cdk:path: HelloCdkStack/HelloWorldFunction/FunctionUrl/Resource
HelloWorldFunctioninvokefunctionurl:
Type: AWS::Lambda::Permission
Properties:
Action: lambda:InvokeFunctionUrl
FunctionName:
Fn::GetAtt:
- HelloWorldFunction
- Arn
FunctionUrlAuthType: NONE
Principal: "*"
Metadata:
aws:cdk:path: HelloCdkStack/HelloWorldFunction/invoke-function-url
CDKMetadata:
Type: AWS::CDK::Metadata
Properties:
Analytics: v2:deflate64:
Metadata:
aws:cdk:path: HelloCdkStack/CDKMetadata/Default
Condition: CDKMetadataAvailable
Outputs:
myFunctionUrlOutput:
Value:
Fn::GetAtt:
- HelloWorldFunctionFunctionUrl
- FunctionUrl
Parameters:
BootstrapVersion:
Type: AWS::SSM::Parameter::Value
Default: /cdk-bootstrap//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.
```
**catatan**
Setiap template yang dihasilkan berisi ` AWS::CDK::Metadata` sumber daya secara default. Tim AWS CDK menggunakan metadata ini untuk mendapatkan wawasan tentang penggunaan AWS CDK dan menemukan cara untuk memperbaikinya. Untuk detail, termasuk cara memilih keluar dari pelaporan versi, lihat [Pelaporan versi](cli.md#version-reporting).
Dengan mendefinisikan satu konstruksi L2, AWS CDK membuat template ekstensif yang CloudFormation berisi sumber daya Lambda Anda, bersama dengan izin dan logika lem yang diperlukan agar sumber daya Anda berinteraksi dalam aplikasi Anda.
## Langkah 9: Menyebarkan tumpukan CDK Anda
Pada langkah ini, Anda menggunakan perintah CDK `cdk deploy` CLI untuk menyebarkan tumpukan CDK Anda. Perintah ini mengambil CloudFormation template yang Anda buat dan menerapkannya AWS CloudFormation, yang menyediakan sumber daya Anda sebagai bagian dari tumpukan. CloudFormation
Dari akar proyek Anda, jalankan yang berikut ini. Konfirmasikan perubahan jika diminta:
```
$ cdk deploy
✨ Synthesis time: 2.69s
HelloCdkStack: start: Building :current_account-current_region
HelloCdkStack: success: Built :current_account-current_region
HelloCdkStack: start: Publishing :current_account-current_region
HelloCdkStack: success: Published :current_account-current_region
This deployment will make potentially sensitive changes according to your current security approval level (--require-approval broadening).
Please confirm you intend to make the following modifications:
IAM Statement Changes
┌───┬───────────────────────────────────────┬────────┬──────────────────────────┬──────────────────────────────┬───────────┐
│ │ Resource │ Effect │ Action │ Principal │ Condition │
├───┼───────────────────────────────────────┼────────┼──────────────────────────┼──────────────────────────────┼───────────┤
│ + │ ${HelloWorldFunction.Arn} │ Allow │ lambda:InvokeFunctionUrl │ * │ │
├───┼───────────────────────────────────────┼────────┼──────────────────────────┼──────────────────────────────┼───────────┤
│ + │ ${HelloWorldFunction/ServiceRole.Arn} │ Allow │ sts:AssumeRole │ Service:lambda.amazonaws.com │ │
└───┴───────────────────────────────────────┴────────┴──────────────────────────┴──────────────────────────────┴───────────┘
IAM Policy Changes
┌───┬───────────────────────────────────┬────────────────────────────────────────────────────────────────────────────────┐
│ │ Resource │ Managed Policy ARN │
├───┼───────────────────────────────────┼────────────────────────────────────────────────────────────────────────────────┤
│ + │ ${HelloWorldFunction/ServiceRole} │ arn:${AWS::Partition}:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole │
└───┴───────────────────────────────────┴────────────────────────────────────────────────────────────────────────────────┘
(NOTE: There may be security-related changes not in this list. See https://github.com/aws/aws-cdk/issues/1299)
Do you wish to deploy these changes (y/n)? y
```
Mirip dengan`cdk synth`, Anda tidak perlu menentukan tumpukan AWS CDK karena aplikasi berisi satu tumpukan.
Selama penerapan, CDK CLI menampilkan informasi kemajuan saat tumpukan Anda diterapkan. Setelah selesai, Anda dapat pergi ke [AWS CloudFormation konsol](https://console.aws.amazon.com/cloudformation/home) untuk melihat `HelloCdkStack` tumpukan Anda. Anda juga dapat pergi ke konsol Lambda untuk melihat sumber daya Anda`HelloWorldFunction`.
Saat penerapan selesai, CDK CLI akan menampilkan URL titik akhir Anda. Salin URL ini untuk langkah selanjutnya. Berikut ini adalah contohnya:
```
...
HelloCdkStack: deploying... [1/1]
HelloCdkStack: creating CloudFormation changeset...
✅ HelloCdkStack
✨ Deployment time: 41.65s
Outputs:
HelloCdkStack.myFunctionUrlOutput = https://.lambda-url..on.aws/
Stack ARN:
arn:aws:cloudformation::stack/HelloCdkStack/
✨ Total time: 44.34s
```
## Langkah 10: Berinteraksi dengan aplikasi Anda AWS
Pada langkah ini, Anda berinteraksi dengan aplikasi Anda AWS dengan menjalankan fungsi Lambda Anda melalui URL fungsi. Saat Anda mengakses URL, fungsi Lambda Anda mengembalikan pesan. `Hello World!`
Untuk menjalankan fungsi Anda, akses URL fungsi melalui browser Anda atau dari baris perintah. Berikut ini adalah contohnya:
```
$ curl https://.lambda-url..on.aws/
"Hello World!"%
```
## Langkah 11: Ubah aplikasi Anda
Pada langkah ini, Anda mengubah pesan yang dikembalikan oleh fungsi Lambda saat dipanggil. Anda melakukan diff menggunakan `cdk diff` perintah CDK CLI untuk melihat pratinjau perubahan Anda dan menerapkan untuk memperbarui aplikasi Anda. Anda kemudian berinteraksi dengan aplikasi Anda AWS untuk melihat pesan baru Anda.
Ubah `myFunction` instance di file tumpukan CDK Anda sebagai berikut:
**Example**
Terletak di`lib/hello-cdk-stack.ts`:
```
// ...
export class HelloCdkStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Modify the Lambda function resource
const myFunction = new lambda.Function(this, "HelloWorldFunction", {
runtime: lambda.Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
handler: "index.handler",
code: lambda.Code.fromInline(`
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello CDK!'),
};
};
`),
});
// ...
}
}
```
Terletak di`lib/hello-cdk-stack.js`:
```
// ...
class HelloCdkStack extends Stack {
constructor(scope, id, props) {
super(scope, id, props);
// Modify the Lambda function resource
const myFunction = new lambda.Function(this, "HelloWorldFunction", {
runtime: lambda.Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
handler: "index.handler",
code: lambda.Code.fromInline(`
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello CDK!'),
};
};
`),
});
// ...
}
}
module.exports = { HelloCdkStack }
```
Terletak di`hello_cdk/hello_cdk_stack.py`:
```
# ...
class HelloCdkStack(Stack):
def __init__(self, scope: Construct, construct_id: str, **kwargs) -> None:
super().__init__(scope, construct_id, **kwargs)
# Modify the Lambda function resource
my_function = _lambda.Function(
self, "HelloWorldFunction",
runtime = _lambda.Runtime.NODEJS_20_X, # Provide any supported Node.js runtime
handler = "index.handler",
code = _lambda.Code.from_inline(
"""
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello CDK!'),
};
};
"""
),
)
# ...
```
Terletak di`src/main/java/…/HelloCdkStack.java`:
```
// ...
public class HelloCdkStack extends Stack {
public HelloCdkStack(final Construct scope, final String id) {
this(scope, id, null);
}
public HelloCdkStack(final Construct scope, final String id, final StackProps props) {
super(scope, id, props);
// Modify the Lambda function resource
Function myFunction = Function.Builder.create(this, "HelloWorldFunction")
.runtime(Runtime.NODEJS_20_X) // Provide any supported Node.js runtime
.handler("index.handler")
.code(Code.fromInline(
"exports.handler = async function(event) {" +
" return {" +
" statusCode: 200," +
" body: JSON.stringify('Hello CDK!')" +
" };" +
"};"))
.build();
// ...
}
}
```
```
// ...
namespace HelloCdk
{
public class HelloCdkStack : Stack
{
internal HelloCdkStack(Construct scope, string id, IStackProps props = null) : base(scope, id, props)
{
// Modify the Lambda function resource
var myFunction = new Function(this, "HelloWorldFunction", new FunctionProps
{
Runtime = Runtime.NODEJS_20_X, // Provide any supported Node.js runtime
Handler = "index.handler",
Code = Code.FromInline(@"
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello CDK!'),
};
};
"),
});
// ...
}
}
}
```
```
// ...
type HelloCdkStackProps struct {
awscdk.StackProps
}
func NewHelloCdkStack(scope constructs.Construct, id string, props *HelloCdkStackProps) awscdk.Stack {
var sprops awscdk.StackProps
if props != nil {
sprops = props.StackProps
}
stack := awscdk.NewStack(scope, &id, &sprops)
// Modify the Lambda function resource
myFunction := awslambda.NewFunction(stack, jsii.String("HelloWorldFunction"), &awslambda.FunctionProps{
Runtime: awslambda.Runtime_NODEJS_20_X(), // Provide any supported Node.js runtime
Handler: jsii.String("index.handler"),
Code: awslambda.Code_FromInline(jsii.String(`
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello CDK!'),
};
};
`)),
})
// ...
}
```
Saat ini, perubahan kode Anda belum membuat pembaruan langsung ke sumber daya Lambda yang Anda gunakan. Kode Anda menentukan status sumber daya yang diinginkan. Untuk memodifikasi sumber daya yang Anda gunakan, Anda akan menggunakan CDK CLI untuk mensintesis status yang diinginkan ke dalam templat baru. AWS CloudFormation Kemudian, Anda akan menerapkan CloudFormation template baru Anda sebagai set perubahan. Set perubahan hanya membuat perubahan yang diperlukan untuk mencapai status baru yang Anda inginkan.
Untuk melihat pratinjau perubahan Anda, jalankan `cdk diff` perintah. Berikut ini adalah contohnya:
```
$ cdk diff
Stack HelloCdkStack
Hold on while we create a read-only change set to get a diff with accurate replacement information (use --method=template to use a less accurate but faster template-only diff)
Resources
[~] AWS::Lambda::Function HelloWorldFunction HelloWorldFunction
└─ [~] Code
└─ [~] .ZipFile:
├─ [-]
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello World!'),
};
};
└─ [+]
exports.handler = async function(event) {
return {
statusCode: 200,
body: JSON.stringify('Hello CDK!'),
};
};
✨ Number of stacks with differences: 1
```
Untuk membuat perbedaan ini, CDK CLI menanyakan AWS akun akun Anda untuk template terbaru AWS CloudFormation untuk tumpukan. `HelloCdkStack` Kemudian, ia membandingkan template terbaru dengan template yang baru saja disintesis dari aplikasi Anda.
Untuk mengimplementasikan perubahan Anda, jalankan `cdk deploy` perintah. Berikut ini adalah contohnya:
```
$ cdk deploy
✨ Synthesis time: 2.12s
HelloCdkStack: start: Building :current_account-current_region
HelloCdkStack: success: Built :current_account-current_region
HelloCdkStack: start: Publishing :current_account-current_region
HelloCdkStack: success: Published :current_account-current_region
HelloCdkStack: deploying... [1/1]
HelloCdkStack: creating CloudFormation changeset...
✅ HelloCdkStack
✨ Deployment time: 26.96s
Outputs:
HelloCdkStack.myFunctionUrlOutput = https://.lambda-url..on.aws/
Stack ARN:
arn:aws:cloudformation::stack/HelloCdkStack/
✨ Total time: 29.07s
```
Untuk berinteraksi dengan aplikasi Anda, ulangi [Langkah 10: Berinteraksi dengan aplikasi Anda di AWS](#hello-world-interact). Berikut ini adalah contohnya:
```
$ curl https://.lambda-url..on.aws/
"Hello CDK!"%
```
## Langkah 12: Hapus aplikasi Anda
Pada langkah ini, Anda menggunakan perintah CDK `cdk destroy` CLI untuk menghapus aplikasi Anda. Perintah ini menghapus CloudFormation tumpukan yang terkait dengan tumpukan CDK Anda, yang mencakup sumber daya yang Anda buat.
Untuk menghapus aplikasi Anda, jalankan `cdk destroy` perintah dan konfirmasikan permintaan Anda untuk menghapus aplikasi. Berikut ini adalah contohnya:
```
$ cdk destroy
Are you sure you want to delete: HelloCdkStack (y/n)? y
HelloCdkStack: destroying... [1/1]
✅ HelloCdkStack: destroyed
```
## Langkah selanjutnya
Selamat\$1 Anda telah menyelesaikan tutorial ini dan telah menggunakan AWS CDK untuk berhasil membuat, memodifikasi, dan menghapus sumber daya di AWS Cloud. Anda sekarang siap untuk mulai menggunakan AWS CDK.
Untuk mempelajari lebih lanjut tentang menggunakan AWS CDK dalam bahasa pemrograman pilihan Anda, lihat [Bekerja dengan pustaka AWS CDK](work-with.md).
Untuk sumber daya tambahan, lihat berikut ini:
+ Cobalah [Lokakarya CDK](https://cdkworkshop.com/) untuk tur yang lebih mendalam yang melibatkan proyek yang lebih kompleks.
+ Lihat [referensi API](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-construct-library.html) untuk mulai menjelajahi konstruksi CDK yang tersedia untuk layanan favorit AWS Anda.
+ Kunjungi [Construct Hub](https://constructs.dev/search?q=&cdk=aws-cdk&cdkver=2&sort=downloadsDesc&offset=0) untuk menemukan konstruksi yang dibuat oleh AWS dan lainnya.
+ Jelajahi [Contoh](https://github.com/aws-samples/aws-cdk-examples) menggunakan AWS CDK.
AWS CDK adalah proyek sumber terbuka. Untuk berkontribusi, lihat [Berkontribusi pada AWS Cloud Development Kit (AWS CDK)](https://github.com/aws/aws-cdk/blob/main/CONTRIBUTING.md).