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.
# Bekerja dengan perpustakaan AWS CDK
Impor dan gunakan library AWS Cloud Development Kit (AWS CDK) untuk menentukan infrastruktur AWS Cloud Anda dengan [bahasa pemrograman yang didukung](languages.md).
## Impor AWS Perpustakaan CDK
[Perpustakaan AWS CDK](libraries.md) sering disebut dengan nama TypeScript paketnya. `aws-cdk-lib` Nama paket sebenarnya bervariasi menurut bahasa. Berikut ini adalah contoh cara menginstal dan mengimpor Perpustakaan CDK:
**Example**
| | |
| --- |--- |
| **Instal** | `npm install aws-cdk-lib` |
| **Impor** | `import * as cdk from 'aws-cdk-lib';` |
| | |
| --- |--- |
| **Instal** | `npm install aws-cdk-lib` |
| **Impor** | `const cdk = require('aws-cdk-lib');` |
| | |
| --- |--- |
| **Instal** | `python -m pip install aws-cdk-lib` |
| **Impor** | `import aws_cdk as cdk` |
| | |
| --- |--- |
| **Di`pom.xml`, tambahkan** | `Group software.amazon.awscdk; artifact aws-cdk-lib` |
| **Impor** | `import software.amazon.awscdk.App;` |
| | |
| --- |--- |
| **Instal** | `dotnet add package Amazon.CDK.Lib` |
| **Impor** | `using Amazon.CDK;` |
| | |
| --- |--- |
| **Instal** | `go get github.com/aws/aws-cdk-go/awscdk/v2` |
| **Impor** |
import ( "github.com/aws/aws-cdk-go/awscdk/v2" )
|
Kelas `construct` dasar dan kode pendukung ada di `constructs` perpustakaan. Konstruksi eksperimental, di mana API masih mengalami penyempurnaan, didistribusikan sebagai modul terpisah.
## Menggunakan Referensi API AWS CDK
Gunakan [referensi AWS CDK API](libraries.md#libraries-reference) saat Anda mengembangkan dengan AWS CDK.
Bahan referensi setiap modul dipecah menjadi bagian-bagian berikut.
+ *Ikhtisar*: Materi pengantar yang perlu Anda ketahui untuk bekerja dengan layanan di AWS CDK, termasuk konsep dan contoh.
+ *Konstruksi*: Kelas perpustakaan yang mewakili satu atau lebih AWS sumber daya konkret. Ini adalah sumber daya atau pola “dikurasi” (L2) (sumber daya L3) yang menyediakan antarmuka tingkat tinggi dengan default yang waras.
+ *Kelas: Kelas* non-konstruksi yang menyediakan fungsionalitas yang digunakan oleh konstruksi dalam modul.
+ *Structs*: Struktur data (bundel atribut) yang mendefinisikan struktur nilai komposit seperti properti (`props`argumen konstruksi) dan opsi.
+ *Antarmuka*: Antarmuka, yang namanya semua dimulai dengan “I”, mendefinisikan fungsionalitas minimum absolut untuk konstruksi yang sesuai atau kelas lainnya. CDK menggunakan antarmuka konstruksi untuk mewakili AWS sumber daya yang ditentukan di luar aplikasi AWS CDK Anda dan direferensikan dengan metode seperti. `Bucket.fromBucketArn()`
+ *Enum*: Koleksi nilai bernama untuk digunakan dalam menentukan parameter konstruksi tertentu. Menggunakan nilai yang disebutkan memungkinkan CDK untuk memeriksa nilai-nilai ini untuk validitas selama sintesis.
+ *CloudFormation Sumber daya*: Konstruksi L1 ini, yang namanya dimulai dengan “Cfn”, mewakili sumber daya yang ditentukan dalam spesifikasi. CloudFormation Mereka secara otomatis dihasilkan dari spesifikasi itu dengan setiap rilis CDK. Setiap konstruksi L2 atau L3 merangkum satu atau lebih sumber daya. CloudFormation
+ *CloudFormation Jenis Properti*: Kumpulan nilai bernama yang menentukan properti untuk setiap CloudFormation Sumber Daya.
## Antarmuka dibandingkan dengan kelas konstruksi
AWS CDK menggunakan antarmuka dengan cara tertentu yang mungkin tidak jelas bahkan jika Anda terbiasa dengan antarmuka sebagai konsep pemrograman.
AWS CDK mendukung penggunaan sumber daya yang didefinisikan di luar aplikasi CDK menggunakan metode seperti. `Bucket.fromBucketArn()` Sumber daya eksternal tidak dapat dimodifikasi dan mungkin tidak memiliki semua fungsionalitas yang tersedia dengan sumber daya yang ditentukan dalam aplikasi CDK Anda menggunakan misalnya `Bucket` kelas. Antarmuka, kemudian, mewakili fungsionalitas minimum yang tersedia di CDK untuk jenis AWS sumber daya tertentu, *termasuk* sumber daya eksternal.
Saat membuat instance resource di aplikasi CDK, Anda harus selalu menggunakan class konkret seperti. `Bucket` Saat menentukan jenis argumen yang Anda terima di salah satu konstruksi Anda sendiri, gunakan tipe antarmuka seperti `IBucket` jika Anda siap untuk berurusan dengan sumber daya eksternal (yaitu, Anda tidak perlu mengubahnya). Jika Anda memerlukan konstruksi yang ditentukan CDK, tentukan jenis paling umum yang dapat Anda gunakan.
Beberapa antarmuka adalah versi minimum properti atau bundel opsi yang terkait dengan kelas tertentu, bukan konstruksi. Antarmuka seperti itu dapat berguna saat mensubklasifikasikan untuk menerima argumen yang akan Anda sampaikan ke kelas induk Anda. Jika Anda memerlukan satu atau lebih properti tambahan, Anda akan ingin menerapkan atau menurunkan dari antarmuka ini, atau dari jenis yang lebih spesifik.
**catatan**
Beberapa bahasa pemrograman yang didukung oleh AWS CDK tidak memiliki fitur antarmuka. Dalam bahasa-bahasa ini, antarmuka hanyalah kelas biasa. Anda dapat mengidentifikasi mereka dengan nama mereka, yang mengikuti pola awal “I” diikuti dengan nama beberapa konstruksi lain (misalnya`IBucket`). Aturan yang sama berlaku.
## Mengelola dependensi
Dependensi untuk aplikasi atau pustaka AWS CDK Anda dikelola menggunakan alat manajemen paket. Alat-alat ini biasanya digunakan dengan bahasa pemrograman.
Biasanya, AWS CDK mendukung alat manajemen paket standar atau resmi bahasa jika ada. Jika tidak, AWS CDK akan mendukung bahasa yang paling populer atau didukung secara luas. Anda mungkin juga dapat menggunakan alat lain, terutama jika mereka bekerja dengan alat yang didukung. Namun, dukungan resmi untuk alat lain terbatas.
AWS CDK mendukung manajer paket berikut:
| Bahasa | Alat manajemen paket yang didukung |
| --- | --- |
| TypeScript/JavaScript | NPM (Node Package Manager) atau Yarn |
| Python | PIP (Package Installer untuk Python) |
| Java | Maven |
| C\$1 | NuGet |
| Go | Modul Go |
Saat Anda membuat proyek baru menggunakan perintah AWS CDK `cdk init` CLI, dependensi untuk pustaka inti CDK dan konstruksi stabil ditentukan secara otomatis.
Untuk informasi selengkapnya tentang mengelola dependensi untuk bahasa pemrograman yang didukung, lihat berikut ini:
+ [Mengelola dependensi](work-with-cdk-typescript.md#work-with-cdk-typescript-dependencies) di. TypeScript
+ [Mengelola dependensi](work-with-cdk-javascript.md#work-with-cdk-javascript-dependencies) di. JavaScript
+ [Mengelola dependensi dengan Python](work-with-cdk-python.md#work-with-cdk-python-dependencies).
+ [Mengelola dependensi di Jawa](work-with-cdk-java.md#work-with-cdk-java-dependencies).
+ [Mengelola dependensi di C \$1](work-with-cdk-csharp.md#work-with-cdk-csharp-dependencies).
+ [Mengelola dependensi di Go](work-with-cdk-go.md#work-with-cdk-go-dependencies).
## Membandingkan AWS CDK TypeScript dengan bahasa lain
TypeScript adalah bahasa pertama yang didukung untuk mengembangkan aplikasi AWS CDK. Oleh karena itu, sejumlah besar contoh kode CDK ditulis dalam TypeScript. Jika Anda mengembangkan dalam bahasa lain, mungkin berguna untuk membandingkan bagaimana kode AWS CDK diimplementasikan TypeScript dibandingkan dengan bahasa pilihan Anda. Ini dapat membantu Anda menggunakan contoh di seluruh dokumentasi.
## Mengimpor modul
**Example**
TypeScript mendukung mengimpor seluruh namespace, atau objek individual dari namespace. Setiap namespace mencakup konstruksi dan kelas lain untuk digunakan dengan layanan yang diberikan. AWS
```
// Import main CDK library as cdk
import * as cdk from 'aws-cdk-lib'; // ES6 import preferred in TS
const cdk = require('aws-cdk-lib'); // Node.js require() preferred in JS
// Import specific core CDK classes
import { Stack, App } from 'aws-cdk-lib';
const { Stack, App } = require('aws-cdk-lib');
// Import AWS S3 namespace as s3 into current namespace
import { aws_s3 as s3 } from 'aws-cdk-lib'; // TypeScript
const s3 = require('aws-cdk-lib/aws-s3'); // JavaScript
// Having imported cdk already as above, this is also valid
const s3 = cdk.aws_s3;
// Now use s3 to access the S3 types
const bucket = s3.Bucket(...);
// Selective import of s3.Bucket
import { Bucket } from 'aws-cdk-lib/aws-s3'; // TypeScript
const { Bucket } = require('aws-cdk-lib/aws-s3'); // JavaScript
// Now use Bucket to instantiate an S3 bucket
const bucket = Bucket(...);
```
Seperti TypeScript, Python mendukung impor modul namespaced dan impor selektif. **Ruang nama dengan Python terlihat seperti aws\$1cdk.** *xxx*, di mana *xxx* mewakili nama AWS layanan, seperti **s3** untuk Amazon S3. (Amazon S3 digunakan dalam contoh-contoh ini).
```
# Import main CDK library as cdk
import aws_cdk as cdk
# Selective import of specific core classes
from aws_cdk import Stack, App
# Import entire module as s3 into current namespace
import aws_cdk.aws_s3 as s3
# s3 can now be used to access classes it contains
bucket = s3.Bucket(...)
# Selective import of s3.Bucket into current namespace
from aws_cdk.s3 import Bucket
# Bucket can now be used to instantiate a bucket
bucket = Bucket(...)
```
Impor Java bekerja secara berbeda dari TypeScript's. Setiap pernyataan impor mengimpor nama kelas tunggal dari paket tertentu, atau semua kelas yang didefinisikan dalam paket itu (menggunakan`\*`). Kelas dapat diakses menggunakan nama kelas dengan sendirinya jika telah diimpor, atau nama kelas yang *memenuhi syarat* termasuk paketnya.
Library dinamai seperti `software.amazon.awscdk.services.xxx` untuk AWS Construct Library (perpustakaan utamanya adalah`software.amazon.awscdk`). ID grup Maven untuk paket AWS CDK adalah. `software.amazon.awscdk`
```
// Make certain core classes available
import software.amazon.awscdk.Stack;
import software.amazon.awscdk.App;
// Make all Amazon S3 construct library classes available
import software.amazon.awscdk.services.s3.*;
// Make only Bucket and EventType classes available
import software.amazon.awscdk.services.s3.Bucket;
import software.amazon.awscdk.services.s3.EventType;
// An imported class may now be accessed using the simple class name (assuming that name
// does not conflict with another class)
Bucket bucket = Bucket.Builder.create(...).build();
// We can always use the qualified name of a class (including its package) even without an
// import directive
software.amazon.awscdk.services.s3.Bucket bucket =
software.amazon.awscdk.services.s3.Bucket.Builder.create(...)
.build();
// Java 10 or later can use var keyword to avoid typing the type twice
var bucket =
software.amazon.awscdk.services.s3.Bucket.Builder.create(...)
.build();
```
Di C \$1, Anda mengimpor tipe dengan `using` arahan. Ada dua gaya. Satu memberi Anda akses ke semua jenis di namespace yang ditentukan dengan menggunakan nama polos mereka. Dengan yang lain, Anda dapat merujuk ke namespace itu sendiri dengan menggunakan alias.
Paket diberi nama seperti `Amazon.CDK.AWS.xxx` untuk paket AWS Construct Library. (Modul inti adalah`Amazon.CDK`.)
```
// Make CDK base classes available under cdk
using cdk = Amazon.CDK;
// Make all Amazon S3 construct library classes available
using Amazon.CDK.AWS.S3;
// Now we can access any S3 type using its name
var bucket = new Bucket(...);
// Import the S3 namespace under an alias
using s3 = Amazon.CDK.AWS.S3;
// Now we can access an S3 type through the namespace alias
var bucket = new s3.Bucket(...);
// We can always use the qualified name of a type (including its namespace) even without a
// using directive
var bucket = new Amazon.CDK.AWS.S3.Bucket(...);
```
Setiap modul AWS Construct Library disediakan sebagai paket Go.
```
import (
"github.com/aws/aws-cdk-go/awscdk/v2" // CDK core package
"github.com/aws/aws-cdk-go/awscdk/v2/awss3" // AWS S3 construct library module
)
// now instantiate a bucket
bucket := awss3.NewBucket(...)
// use aliases for brevity/clarity
import (
cdk "github.com/aws/aws-cdk-go/awscdk/v2" // CDK core package
s3 "github.com/aws/aws-cdk-go/awscdk/v2/awss3" // AWS S3 construct library module
)
bucket := s3.NewBucket(...)
```
## Membuat instantiasi sebuah konstruksi
AWS Kelas konstruksi CDK memiliki nama yang sama di semua bahasa yang didukung. Sebagian besar bahasa menggunakan `new` kata kunci untuk membuat instance kelas (Python dan Go tidak). Juga, dalam sebagian besar bahasa, kata kunci `this` mengacu pada contoh saat ini. (Python menggunakan `self` berdasarkan konvensi.) Anda harus meneruskan referensi ke instance saat ini sebagai `scope` parameter untuk setiap konstruksi yang Anda buat.
Argumen ketiga untuk konstruksi AWS CDK adalah`props`, objek yang berisi atribut yang diperlukan untuk membangun konstruksi. Argumen ini mungkin opsional, tetapi ketika diperlukan, bahasa yang didukung menanganinya dengan cara idiomatik. Nama-nama atribut juga disesuaikan dengan pola penamaan standar bahasa.
**Example**
```
// Instantiate default Bucket
const bucket = new s3.Bucket(this, 'amzn-s3-demo-bucket');
// Instantiate Bucket with bucketName and versioned properties
const bucket = new s3.Bucket(this, 'amzn-s3-demo-bucket', {
bucketName: 'amzn-s3-demo-bucket',
versioned: true,
});
// Instantiate Bucket with websiteRedirect, which has its own sub-properties
const bucket = new s3.Bucket(this, 'amzn-s3-demo-bucket', {
websiteRedirect: {host: 'aws.amazon.com'}});
```
Python tidak menggunakan `new` kata kunci saat membuat instance kelas. Argumen properti direpresentasikan menggunakan argumen kata kunci, dan argumen diberi nama menggunakan`snake_case`.
Jika nilai props itu sendiri merupakan bundel atribut, itu diwakili oleh kelas dinamai setelah properti, yang menerima argumen kata kunci untuk subproperti.
Dalam Python, instance saat ini diteruskan ke metode sebagai argumen pertama, yang dinamai `self` oleh konvensi.
```
# Instantiate default Bucket
bucket = s3.Bucket(self, "amzn-s3-demo-bucket")
# Instantiate Bucket with bucket_name and versioned properties
bucket = s3.Bucket(self, "amzn-s3-demo-bucket", bucket_name="amzn-s3-demo-bucket", versioned=true)
# Instantiate Bucket with website_redirect, which has its own sub-properties
bucket = s3.Bucket(self, "amzn-s3-demo-bucket", website_redirect=s3.WebsiteRedirect(
host_name="aws.amazon.com"))
```
Di Jawa, argumen props diwakili oleh kelas bernama `XxxxProps` (misalnya, `BucketProps` untuk alat peraga `Bucket` konstruksi). Anda membangun argumen props menggunakan pola pembangun.
Setiap `XxxxProps` kelas memiliki pembangun. Ada juga pembangun yang nyaman untuk setiap konstruksi yang membangun alat peraga dan konstruksi dalam satu langkah, seperti yang ditunjukkan pada contoh berikut.
Alat peraga diberi nama sama seperti di TypeScript, menggunakan`camelCase`.
```
// Instantiate default Bucket
Bucket bucket = Bucket(self, "amzn-s3-demo-bucket");
// Instantiate Bucket with bucketName and versioned properties
Bucket bucket = Bucket.Builder.create(self, "amzn-s3-demo-bucket")
.bucketName("amzn-s3-demo-bucket").versioned(true)
.build();
# Instantiate Bucket with websiteRedirect, which has its own sub-properties
Bucket bucket = Bucket.Builder.create(self, "amzn-s3-demo-bucket")
.websiteRedirect(new websiteRedirect.Builder()
.hostName("aws.amazon.com").build())
.build();
```
Dalam C \$1, alat peraga ditentukan menggunakan penginisialisasi objek ke kelas bernama `XxxxProps` (misalnya, `BucketProps` untuk alat peraga `Bucket` konstruksi).
Alat peraga diberi nama mirip dengan TypeScript, kecuali menggunakan`PascalCase`.
Lebih mudah menggunakan `var` kata kunci saat membuat instance konstruksi, jadi Anda tidak perlu mengetikkan nama kelas dua kali. Namun, panduan gaya kode lokal Anda mungkin berbeda.
```
// Instantiate default Bucket
var bucket = Bucket(self, "amzn-s3-demo-bucket");
// Instantiate Bucket with BucketName and Versioned properties
var bucket = Bucket(self, "amzn-s3-demo-bucket", new BucketProps {
BucketName = "amzn-s3-demo-bucket",
Versioned = true});
// Instantiate Bucket with WebsiteRedirect, which has its own sub-properties
var bucket = Bucket(self, "amzn-s3-demo-bucket", new BucketProps {
WebsiteRedirect = new WebsiteRedirect {
HostName = "aws.amazon.com"
}});
```
Untuk membuat konstruk di Go, panggil fungsi `NewXxxxxx` di mana `Xxxxxxx` adalah nama konstruksi. Properti konstruksi didefinisikan sebagai struct.
Di Go, semua parameter konstruksi adalah pointer, termasuk nilai seperti angka, Boolean, dan string. Gunakan fungsi kenyamanan seperti `jsii.String` untuk membuat pointer ini.
```
// Instantiate default Bucket
bucket := awss3.NewBucket(stack, jsii.String("amzn-s3-demo-bucket"), nil)
// Instantiate Bucket with BucketName and Versioned properties
bucket1 := awss3.NewBucket(stack, jsii.String("amzn-s3-demo-bucket"), &awss3.BucketProps{
BucketName: jsii.String("amzn-s3-demo-bucket"),
Versioned: jsii.Bool(true),
})
// Instantiate Bucket with WebsiteRedirect, which has its own sub-properties
bucket2 := awss3.NewBucket(stack, jsii.String("amzn-s3-demo-bucket"), &awss3.BucketProps{
WebsiteRedirect: &awss3.RedirectTarget{
HostName: jsii.String("aws.amazon.com"),
}})
```
## Mengakses anggota
Adalah umum untuk merujuk pada atribut atau properti konstruksi dan kelas AWS CDK lainnya dan menggunakan nilai-nilai ini sebagai, misalnya, input untuk membangun konstruksi lain. Perbedaan penamaan yang dijelaskan sebelumnya untuk metode berlaku di sini juga. Selain itu, di Jawa, tidak mungkin untuk mengakses anggota secara langsung. Sebagai gantinya, metode pengambil disediakan.
**Example**
Nama-nama adalah`camelCase`.
```
bucket.bucketArn
```
Nama-nama adalah`snake_case`.
```
bucket.bucket_arn
```
Metode getter disediakan untuk setiap properti; nama-nama ini adalah`camelCase`.
```
bucket.getBucketArn()
```
Nama-nama adalah`PascalCase`.
```
bucket.BucketArn
```
Nama-nama adalah`PascalCase`.
```
bucket.BucketArn
```
## Konstanta enum
Konstanta enum dicakup ke kelas, dan memiliki nama huruf besar dengan garis bawah dalam semua bahasa (kadang-kadang disebut sebagai). `SCREAMING_SNAKE_CASE` Karena nama kelas juga menggunakan casing yang sama di semua bahasa yang didukung kecuali Go, nama enum yang memenuhi syarat juga sama dalam bahasa ini.
```
s3.BucketEncryption.KMS_MANAGED
```
Di Go, konstanta enum adalah atribut dari namespace modul dan ditulis sebagai berikut.
```
awss3.BucketEncryption_KMS_MANAGED
```
## Antarmuka objek
AWS CDK menggunakan antarmuka TypeScript objek untuk menunjukkan bahwa kelas mengimplementasikan serangkaian metode dan properti yang diharapkan. Anda dapat mengenali antarmuka objek karena namanya dimulai dengan`I`. Kelas konkret menunjukkan antarmuka yang diimplementasikan dengan menggunakan kata kunci. `implements`
**Example**
JavaScript tidak memiliki fitur antarmuka. Anda dapat mengabaikan `implements` kata kunci dan nama kelas yang mengikutinya.
```
import { IAspect, IConstruct } from 'aws-cdk-lib';
class MyAspect implements IAspect {
public visit(node: IConstruct) {
console.log('Visited', node.node.path);
}
}
```
Python tidak memiliki fitur antarmuka. Namun, untuk AWS CDK Anda dapat menunjukkan implementasi antarmuka dengan mendekorasi kelas Anda. `@jsii.implements(interface)`
```
from aws_cdk import IAspect, IConstruct
import jsii
@jsii.implements(IAspect)
class MyAspect():
def visit(self, node: IConstruct) -> None:
print("Visited", node.node.path)
```
```
import software.amazon.awscdk.IAspect;
import software.amazon.awscdk.IConstruct;
public class MyAspect implements IAspect {
public void visit(IConstruct node) {
System.out.format("Visited %s", node.getNode().getPath());
}
}
```
```
using Amazon.CDK;
public class MyAspect : IAspect
{
public void Visit(IConstruct node)
{
System.Console.WriteLine($"Visited ${node.Node.Path}");
}
}
```
Go struct tidak perlu secara eksplisit mendeklarasikan antarmuka mana yang mereka terapkan. Kompiler Go menentukan implementasi berdasarkan metode dan properti yang tersedia pada struktur. Misalnya, dalam kode berikut, `MyAspect` mengimplementasikan `IAspect` antarmuka karena menyediakan `Visit` metode yang mengambil konstruksi.
```
type MyAspect struct {
}
func (a MyAspect) Visit(node constructs.IConstruct) {
fmt.Println("Visited", *node.Node().Path())
}
```
# Bekerja dengan AWS CDK di TypeScript
TypeScript adalah bahasa klien yang didukung penuh untuk AWS Cloud Development Kit (AWS CDK) dan dianggap stabil. Bekerja dengan AWS CDK TypeScript menggunakan alat yang sudah dikenal, termasuk TypeScript compiler Microsoft (`tsc`), [Node.js](https://nodejs.org/) dan Node Package Manager (`npm`). Anda juga dapat menggunakan [Yarn](https://yarnpkg.com/) jika Anda mau, meskipun contoh dalam Panduan ini menggunakan NPM. [Modul yang terdiri dari AWS Construct Library didistribusikan melalui repositori NPM, npmjs.org.](https://www.npmjs.com/)
Anda dapat menggunakan editor atau IDE apa pun. Banyak pengembang AWS CDK menggunakan [Visual Studio Code](https://code.visualstudio.com/) (atau padanan open-source [VSCodium](https://vscodium.com/)), yang memiliki dukungan yang sangat baik untuk. TypeScript
## Memulai dengan TypeScript
Untuk bekerja dengan AWS CDK, Anda harus memiliki AWS akun dan kredensil dan telah menginstal Node.js dan CDK Toolkit. AWS Lihat [Memulai dengan AWS CDK](getting-started.md).
Anda juga membutuhkan TypeScript dirinya sendiri (versi 3.8 atau yang lebih baru). Jika Anda belum memilikinya, Anda dapat menginstalnya menggunakan`npm`.
```
$ npm install -g typescript
```
**catatan**
Jika Anda mendapatkan kesalahan izin, dan memiliki akses administrator di sistem Anda, coba`sudo npm install -g typescript`.
Tetap TypeScript up to date dengan reguler`npm update -g typescript`.
**catatan**
Penghentian bahasa pihak ketiga: versi bahasa hanya didukung hingga EOL (End Of Life) dibagikan oleh vendor atau komunitas dan dapat berubah sewaktu-waktu dengan pemberitahuan sebelumnya.
## Membuat proyek
Anda membuat proyek AWS CDK baru dengan memanggil `cdk init` di direktori kosong. Gunakan `--language` opsi dan tentukan`typescript`:
```
$ mkdir my-project
$ cd my-project
$ cdk init app --language typescript
```
Membuat proyek juga menginstal [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib-readme.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib-readme.html)modul dan dependensinya.
`cdk init`menggunakan nama folder proyek untuk memberi nama berbagai elemen proyek, termasuk kelas, subfolder, dan file. Tanda hubung dalam nama folder diubah menjadi garis bawah. Namun, nama tersebut harus mengikuti bentuk TypeScript pengenal; misalnya, tidak boleh dimulai dengan angka atau berisi spasi.
## Menggunakan lokal `tsc` dan `cdk`
Untuk sebagian besar, panduan ini mengasumsikan Anda menginstal TypeScript dan CDK Toolkit global (`npm install -g typescript aws-cdk`), dan contoh perintah yang disediakan (seperti`cdk synth`) mengikuti asumsi ini. Pendekatan ini memudahkan untuk menjaga kedua komponen tetap up to date, dan karena keduanya mengambil pendekatan ketat untuk kompatibilitas mundur, umumnya ada sedikit risiko untuk selalu menggunakan versi terbaru.
Beberapa tim lebih memilih untuk menentukan semua dependensi dalam setiap proyek, termasuk alat seperti TypeScript kompiler dan CDK Toolkit. Praktik ini memungkinkan Anda menyematkan komponen ini ke versi tertentu dan memastikan bahwa semua pengembang di tim Anda (dan lingkungan CI/CD Anda) menggunakan versi tersebut dengan tepat. Ini menghilangkan kemungkinan sumber perubahan, membantu membuat build dan penerapan lebih konsisten dan berulang.
CDK menyertakan dependensi untuk keduanya TypeScript dan CDK Toolkit di template TypeScript proyek`package.json`, jadi jika Anda ingin menggunakan pendekatan ini, Anda tidak perlu membuat perubahan apa pun pada proyek Anda. Yang perlu Anda lakukan adalah menggunakan perintah yang sedikit berbeda untuk membangun aplikasi Anda dan untuk mengeluarkan `cdk` perintah.
| Operasi | Gunakan alat global | Gunakan alat lokal |
| --- | --- | --- |
| **Inisialisasi proyek** | `cdk init --language typescript` | `npx aws-cdk init --language typescript` |
| **Membangun** | `tsc` | `npm run build` |
| **Jalankan perintah CDK Toolkit** | `cdk …` | `npm run cdk …` atau `npx aws-cdk …` |
`npx aws-cdk`menjalankan versi CDK Toolkit yang diinstal secara lokal di proyek saat ini, jika ada, kembali ke instalasi global, jika ada. Jika tidak ada instalasi global, `npx` unduh salinan sementara CDK Toolkit dan jalankan itu. Anda dapat menentukan versi arbitrer dari CDK Toolkit menggunakan `@` sintaks: prints. `npx aws-cdk@2.0 --version` `2.0.0`
**Tip**
Siapkan alias sehingga Anda dapat menggunakan `cdk` perintah dengan instalasi CDK Toolkit lokal.
```
$ alias cdk="npx aws-cdk"
```
```
doskey cdk=npx aws-cdk $*
```
## Mengelola AWS modul Construct Library
Gunakan Node Package Manager (`npm`) untuk menginstal dan memperbarui modul AWS Construct Library untuk digunakan oleh aplikasi Anda, serta paket lain yang Anda butuhkan. (Anda dapat menggunakan `yarn` bukan `npm` jika Anda mau.) `npm`juga menginstal dependensi untuk modul-modul tersebut secara otomatis.
Sebagian besar konstruksi AWS CDK berada dalam paket CDK utama, bernama`aws-cdk-lib`, yang merupakan ketergantungan default dalam proyek baru yang dibuat oleh. `cdk init` Modul Perpustakaan AWS Konstruksi “Eksperimental”, di mana konstruksi tingkat yang lebih tinggi masih dalam pengembangan, diberi nama seperti. `@aws-cdk/-alpha` Nama layanan memiliki awalan *aws-*. Jika Anda tidak yakin dengan nama modul, [cari di NPM](https://www.npmjs.com/search?q=%40aws-cdk).
**catatan**
[Referensi API CDK](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-construct-library.html) juga menunjukkan nama paket.
Misalnya, perintah di bawah ini menginstal modul eksperimental untuk AWS CodeStar.
```
$ npm install @aws-cdk/aws-codestar-alpha
```
Dukungan Construct Library beberapa layanan ada di lebih dari satu namespace. Misalnya, selain itu`aws-route53`, ada tiga ruang nama Amazon Route 53 tambahan,, `aws-route53-targets``aws-route53-patterns`, dan. `aws-route53resolver`
Dependensi proyek Anda dipertahankan di. `package.json` Anda dapat mengedit file ini untuk mengunci beberapa atau semua dependensi Anda ke versi tertentu atau untuk memungkinkan mereka diperbarui ke versi yang lebih baru di bawah kriteria tertentu. Untuk memperbarui dependensi NPM project Anda ke versi terbaru yang diizinkan sesuai dengan aturan yang Anda tentukan di: `package.json`
```
$ npm update
```
Di TypeScript, Anda mengimpor modul ke kode Anda dengan nama yang sama yang Anda gunakan untuk menginstalnya menggunakan NPM. Kami merekomendasikan praktik berikut saat mengimpor kelas AWS CDK dan modul AWS Construct Library di aplikasi Anda. Mengikuti panduan ini akan membantu membuat kode Anda konsisten dengan aplikasi AWS CDK lainnya serta lebih mudah dipahami.
+ Gunakan `import` arahan ES6 -style, bukan. `require()`
+ Umumnya, impor kelas individu dari`aws-cdk-lib`.
```
import { App, Stack } from 'aws-cdk-lib';
```
+ Jika Anda membutuhkan banyak kelas`aws-cdk-lib`, Anda dapat menggunakan alias namespace `cdk` alih-alih mengimpor kelas individual. Hindari melakukan keduanya.
```
import * as cdk from 'aws-cdk-lib';
```
+ Umumnya, impor konstruksi AWS layanan menggunakan alias namespace pendek.
```
import { aws_s3 as s3 } from 'aws-cdk-lib';
```
## Mengelola dependensi di TypeScript
Dalam proyek TypeScript CDK, dependensi ditentukan dalam `package.json` file di direktori utama proyek. Modul AWS CDK inti berada dalam satu `NPM` paket yang disebut`aws-cdk-lib`.
Saat Anda menginstal paket menggunakan`npm install`, NPM mencatat paket `package.json` untuk Anda.
Jika mau, Anda dapat menggunakan Benang sebagai pengganti NPM. Namun, CDK tidak mendukung plug-and-play mode Yarn, yang merupakan mode default di Yarn 2. Tambahkan berikut ini ke `.yarnrc.yml` file proyek Anda untuk mematikan fitur ini.
```
nodeLinker: node-modules
```
### Aplikasi CDK
Berikut ini adalah contoh `package.json` file yang dihasilkan oleh `cdk init --language typescript` perintah:
```
{
"name": "my-package",
"version": "0.1.0",
"bin": {
"my-package": "bin/my-package.js"
},
"scripts": {
"build": "tsc",
"watch": "tsc -w",
"test": "jest",
"cdk": "cdk"
},
"devDependencies": {
"@types/jest": "^26.0.10",
"@types/node": "10.17.27",
"jest": "^26.4.2",
"ts-jest": "^26.2.0",
"aws-cdk": "2.16.0",
"ts-node": "^9.0.0",
"typescript": "~3.9.7"
},
"dependencies": {
"aws-cdk-lib": "2.16.0",
"constructs": "^10.0.0",
"source-map-support": "^0.5.16"
}
}
```
Untuk aplikasi CDK yang dapat di-deploy, `aws-cdk-lib` harus ditentukan di bagian. `dependencies` `package.json` Anda dapat menggunakan penentu nomor versi tanda sisipan (^) untuk menunjukkan bahwa Anda akan menerima versi yang lebih baru dari yang ditentukan selama mereka berada dalam versi utama yang sama.
Untuk konstruksi eksperimental, tentukan versi yang tepat untuk modul pustaka konstruksi alfa, APIs yang mungkin berubah. Jangan gunakan ^ atau \$1 karena versi modul ini yang lebih baru dapat membawa perubahan API yang dapat merusak aplikasi Anda.
Tentukan versi pustaka dan alat yang diperlukan untuk menguji aplikasi Anda (misalnya, kerangka `jest` pengujian) di `devDependencies` bagian. `package.json` Secara opsional, gunakan ^ untuk menentukan bahwa versi yang kompatibel selanjutnya dapat diterima.
### Perpustakaan konstruksi pihak ketiga
Jika Anda mengembangkan pustaka konstruksi, tentukan dependensinya menggunakan kombinasi `devDependencies` bagian `peerDependencies` dan, seperti yang ditunjukkan pada file contoh berikut. `package.json`
```
{
"name": "my-package",
"version": "0.0.1",
"peerDependencies": {
"aws-cdk-lib": "^2.14.0",
"@aws-cdk/aws-appsync-alpha": "2.10.0-alpha",
"constructs": "^10.0.0"
},
"devDependencies": {
"aws-cdk-lib": "2.14.0",
"@aws-cdk/aws-appsync-alpha": "2.10.0-alpha",
"constructs": "10.0.0",
"jsii": "^1.50.0",
"aws-cdk": "^2.14.0"
}
}
```
Di`peerDependencies`, gunakan tanda sisipan (^) untuk menentukan versi terendah `aws-cdk-lib` yang digunakan perpustakaan Anda. Ini memaksimalkan kompatibilitas perpustakaan Anda dengan berbagai versi CDK. Tentukan versi yang tepat untuk modul pustaka konstruksi alfa, APIs yang mungkin berubah. Menggunakan `peerDependencies` memastikan bahwa hanya ada satu salinan dari semua perpustakaan CDK di pohon. `node_modules`
Di`devDependencies`, tentukan alat dan pustaka yang Anda butuhkan untuk pengujian, secara opsional dengan ^ untuk menunjukkan bahwa versi kompatibel yang lebih baru dapat diterima. Tentukan dengan tepat (tanpa ^ atau \$1) versi terendah `aws-cdk-lib` dan paket CDK lainnya yang kompatibel dengan perpustakaan Anda. Praktik ini memastikan bahwa pengujian Anda berjalan terhadap versi tersebut. Dengan cara ini, jika Anda secara tidak sengaja menggunakan fitur yang hanya ditemukan di versi yang lebih baru, pengujian Anda dapat menangkapnya.
**Awas**
`peerDependencies`diinstal secara otomatis hanya oleh NPM 7 dan yang lebih baru. Jika Anda menggunakan NPM 6 atau sebelumnya, atau jika Anda menggunakan Yarn, Anda harus menyertakan dependensi dependensi Anda di. `devDependencies` Jika tidak, mereka tidak akan diinstal, dan Anda akan menerima peringatan tentang dependensi rekan yang belum terselesaikan.
### Menginstal dan memperbarui dependensi
Jalankan perintah berikut untuk menginstal dependensi proyek Anda.
**Example**
```
# Install the latest version of everything that matches the ranges in 'package.json'
npm install
# Install the same exact dependency versions as recorded in 'package-lock.json'
npm ci
```
```
# Install the latest version of everything that matches the ranges in 'package.json'
$ yarn upgrade
# Install the same exact dependency versions as recorded in 'yarn.lock'
$ yarn install --frozen-lockfile
```
Untuk memperbarui modul yang diinstal, `yarn upgrade` perintah sebelumnya `npm install` dan dapat digunakan. Perintah mana pun memperbarui paket `node_modules` ke versi terbaru yang memenuhi aturan di`package.json`. Namun, mereka tidak memperbarui `package.json` dirinya sendiri, yang mungkin ingin Anda lakukan untuk menetapkan versi minimum baru. Jika Anda meng-host paket Anda GitHub, Anda dapat mengonfigurasi [pembaruan versi Dependabot untuk memperbarui](https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/configuring-dependabot-version-updates) secara otomatis. `package.json` Alternatif lainnya, gunakan [npm-check-updates](https://www.npmjs.com/package/npm-check-updates).
**penting**
Secara desain, ketika Anda menginstal atau memperbarui dependensi, NPM dan Yarn memilih versi terbaru dari setiap paket yang memenuhi persyaratan yang ditentukan dalam. `package.json` Selalu ada risiko bahwa versi ini dapat rusak (baik secara tidak sengaja atau sengaja). Uji secara menyeluruh setelah memperbarui dependensi proyek Anda.
## AWS Idiom CDK di TypeScript
### Alat Peraga
**Semua kelas AWS Construct Library dipakai menggunakan tiga argumen: *lingkup* di mana konstruksi sedang didefinisikan (induknya di pohon konstruksi), id, dan alat peraga.** Argumen *props* adalah bundel pasangan kunci/nilai yang digunakan konstruksi untuk mengkonfigurasi sumber daya yang dibuatnya. AWS Kelas dan metode lain juga menggunakan pola “bundel atribut” untuk argumen.
Dalam TypeScript, bentuk `props` didefinisikan menggunakan antarmuka yang memberi tahu Anda argumen yang diperlukan dan opsional serta tipenya. Antarmuka seperti didefinisikan untuk setiap jenis `props` argumen, biasanya khusus untuk konstruksi tunggal atau metode. Misalnya, [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.Bucket.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.Bucket.html)konstruksi (dalam `aws-cdk-lib/aws-s3` modul) menentukan `props` argumen yang sesuai dengan antarmuka. [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html)
Jika properti itu sendiri merupakan objek, misalnya [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html#websiteredirect](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.BucketProps.html#websiteredirect)properti dari`BucketProps`, objek itu akan memiliki antarmuka sendiri yang bentuknya harus sesuai, dalam hal [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.RedirectTarget.html](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_s3.RedirectTarget.html)ini.
Jika Anda mensubklasifikasikan kelas AWS Construct Library (atau mengganti metode yang menggunakan argumen seperti props), Anda dapat mewarisi dari antarmuka yang ada untuk membuat yang baru yang menentukan alat peraga baru yang diperlukan kode Anda. Saat memanggil kelas induk atau metode dasar, umumnya Anda dapat meneruskan seluruh argumen props yang Anda terima, karena atribut apa pun yang disediakan dalam objek tetapi tidak ditentukan dalam antarmuka akan diabaikan.
Rilis AWS CDK di masa depan secara kebetulan dapat menambahkan properti baru dengan nama yang Anda gunakan untuk properti Anda sendiri. Melewati nilai yang Anda terima ke rantai pewarisan kemudian dapat menyebabkan perilaku yang tidak terduga. Lebih aman untuk meneruskan salinan dangkal alat peraga yang Anda terima dengan properti Anda dihapus atau disetel ke`undefined`. Misalnya:
```
super(scope, name, {...props, encryptionKeys: undefined});
```
Atau, beri nama properti Anda sehingga jelas bahwa mereka milik konstruksi Anda. Dengan cara ini, kecil kemungkinan mereka akan bertabrakan dengan properti di rilis AWS CDK masa depan. Jika ada banyak dari mereka, gunakan satu objek dengan nama yang tepat untuk menahannya.
### Nilai yang hilang
Nilai yang hilang dalam suatu objek (seperti alat peraga) memiliki nilai `undefined` dalam TypeScript. Versi 3.7 dari bahasa memperkenalkan operator yang menyederhanakan bekerja dengan nilai-nilai ini, sehingga lebih mudah untuk menentukan default dan rantai “hubung singkat” ketika nilai yang tidak ditentukan tercapai. Untuk informasi lebih lanjut tentang fitur-fitur ini, lihat [Catatan Rilis TypeScript 3.7](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html), khususnya dua fitur pertama, Optional Chaining dan Nullish Coalescing.
## Membangun dan menjalankan aplikasi CDK
Umumnya, Anda harus berada di direktori root proyek saat membangun dan menjalankan aplikasi Anda.
Node.js tidak dapat berjalan TypeScript secara langsung; sebagai gantinya, aplikasi Anda dikonversi untuk JavaScript menggunakan TypeScript kompiler,`tsc`. JavaScript Kode yang dihasilkan kemudian dieksekusi.
AWS CDK secara otomatis melakukan ini kapan pun perlu menjalankan aplikasi Anda. Namun, dapat berguna untuk mengkompilasi secara manual untuk memeriksa kesalahan dan menjalankan tes. Untuk mengompilasi TypeScript aplikasi Anda secara manual, masalah`npm run build`. Anda juga dapat mengeluarkan masalah `npm run watch` untuk masuk ke mode tontonan, di mana TypeScript kompiler secara otomatis membangun kembali aplikasi Anda setiap kali Anda menyimpan perubahan ke file sumber.
# Bekerja dengan AWS CDK di JavaScript
JavaScript adalah bahasa klien yang didukung penuh untuk AWS CDK dan dianggap stabil. Bekerja dengan AWS Cloud Development Kit (AWS CDK) JavaScript menggunakan alat yang sudah dikenal, termasuk [Node.js](https://nodejs.org/) dan Node Package Manager (`npm`). Anda juga dapat menggunakan [Yarn](https://yarnpkg.com/) jika Anda mau, meskipun contoh dalam Panduan ini menggunakan NPM. [Modul yang terdiri dari AWS Construct Library didistribusikan melalui repositori NPM, npmjs.org.](https://www.npmjs.com/)
Anda dapat menggunakan editor atau IDE apa pun. Banyak pengembang AWS CDK menggunakan [Visual Studio Code](https://code.visualstudio.com/) (atau padanan open-source [VSCodium](https://vscodium.com/)), yang memiliki dukungan yang baik untuk. JavaScript
## Memulai dengan JavaScript
Untuk bekerja dengan AWS CDK, Anda harus memiliki AWS akun dan kredensil dan telah menginstal Node.js dan CDK Toolkit. AWS Lihat [Memulai dengan AWS CDK](getting-started.md).
JavaScript AWS Aplikasi CDK tidak memerlukan prasyarat tambahan di luar ini.
**catatan**
Pengakhiran bahasa pihak ketiga: versi bahasa hanya didukung hingga EOL (End Of Life) dibagikan oleh vendor atau komunitas dan dapat berubah sewaktu-waktu dengan pemberitahuan sebelumnya.
## Membuat proyek
Anda membuat proyek AWS CDK baru dengan memanggil `cdk init` di direktori kosong. Gunakan `--language` opsi dan tentukan`javascript`:
```
$ mkdir my-project
$ cd my-project
$ cdk init app --language javascript
```
Membuat proyek juga menginstal [aws-cdk-lib](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib-readme.html)modul dan dependensinya.
`cdk init`menggunakan nama folder proyek untuk memberi nama berbagai elemen proyek, termasuk kelas, subfolder, dan file. Tanda hubung dalam nama folder diubah menjadi garis bawah. Namun, nama tersebut harus mengikuti bentuk JavaScript pengenal; misalnya, tidak boleh dimulai dengan angka atau berisi spasi.
## Menggunakan lokal `cdk`
Untuk sebagian besar, panduan ini mengasumsikan Anda menginstal CDK Toolkit global (`npm install -g aws-cdk`), dan contoh perintah yang disediakan (seperti`cdk synth`) mengikuti asumsi ini. Pendekatan ini memudahkan untuk menjaga CDK Toolkit tetap up to date, dan karena CDK mengambil pendekatan ketat untuk kompatibilitas mundur, umumnya ada sedikit risiko untuk selalu menggunakan versi terbaru.
Beberapa tim lebih memilih untuk menentukan semua dependensi dalam setiap proyek, termasuk alat seperti CDK Toolkit. Praktik ini memungkinkan Anda menyematkan komponen tersebut ke versi tertentu dan memastikan bahwa semua pengembang di tim Anda (dan CI/CD lingkungan Anda) menggunakan versi tersebut dengan tepat. Ini menghilangkan kemungkinan sumber perubahan, membantu membuat build dan penerapan lebih konsisten dan berulang.
CDK menyertakan ketergantungan untuk CDK Toolkit dalam template JavaScript proyek`package.json`, jadi jika Anda ingin menggunakan pendekatan ini, Anda tidak perlu membuat perubahan apa pun pada proyek Anda. Yang perlu Anda lakukan adalah menggunakan perintah yang sedikit berbeda untuk membangun aplikasi Anda dan untuk mengeluarkan `cdk` perintah.
| Operasi | Gunakan alat global | Gunakan alat lokal |
| --- | --- | --- |
| **Inisialisasi proyek** | `cdk init --language javascript` | `npx aws-cdk init --language javascript` |
| **Jalankan perintah CDK Toolkit** | `cdk …` | `npm run cdk …` atau `npx aws-cdk …` |
`npx aws-cdk`menjalankan versi CDK Toolkit yang diinstal secara lokal di proyek saat ini, jika ada, kembali ke instalasi global, jika ada. Jika tidak ada instalasi global, `npx` unduh salinan sementara CDK Toolkit dan jalankan itu. Anda dapat menentukan versi arbitrer dari CDK Toolkit menggunakan `@` sintaks: prints. `npx aws-cdk@1.120 --version` `1.120.0`
**Tip**
Siapkan alias sehingga Anda dapat menggunakan `cdk` perintah dengan instalasi CDK Toolkit lokal.
```
$ alias cdk="npx aws-cdk"
```
```
doskey cdk=npx aws-cdk $*
```
## Mengelola AWS modul Construct Library
Gunakan Node Package Manager (`npm`) untuk menginstal dan memperbarui modul AWS Construct Library untuk digunakan oleh aplikasi Anda, serta paket lain yang Anda butuhkan. (Anda dapat menggunakan `yarn` bukan `npm` jika Anda mau.) `npm`juga menginstal dependensi untuk modul-modul tersebut secara otomatis.
Sebagian besar konstruksi AWS CDK berada dalam paket CDK utama, bernama`aws-cdk-lib`, yang merupakan ketergantungan default dalam proyek baru yang dibuat oleh. `cdk init` Modul Perpustakaan AWS Konstruksi “Eksperimental”, di mana konstruksi tingkat yang lebih tinggi masih dalam pengembangan, diberi nama seperti. `aws-cdk-lib/-alpha` Nama layanan memiliki awalan *aws-*. Jika Anda tidak yakin dengan nama modul, [cari di NPM](https://www.npmjs.com/search?q=%40aws-cdk).
**catatan**
[Referensi API CDK](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-construct-library.html) juga menunjukkan nama paket.
Misalnya, perintah di bawah ini menginstal modul eksperimental untuk AWS CodeStar.
```
npm install @aws-cdk/aws-codestar-alpha
```
Dukungan Construct Library beberapa layanan ada di lebih dari satu namespace. Misalnya, selain itu`aws-route53`, ada tiga ruang nama Amazon Route 53 tambahan,, `aws-route53-targets``aws-route53-patterns`, dan. `aws-route53resolver`
Dependensi proyek Anda dipertahankan di. `package.json` Anda dapat mengedit file ini untuk mengunci beberapa atau semua dependensi Anda ke versi tertentu atau untuk memungkinkan mereka diperbarui ke versi yang lebih baru di bawah kriteria tertentu. Untuk memperbarui dependensi NPM project Anda ke versi terbaru yang diizinkan sesuai dengan aturan yang Anda tentukan di: `package.json`
```
npm update
```
Di JavaScript, Anda mengimpor modul ke kode Anda dengan nama yang sama yang Anda gunakan untuk menginstalnya menggunakan NPM. Kami merekomendasikan praktik berikut saat mengimpor kelas AWS CDK dan modul AWS Construct Library di aplikasi Anda. Mengikuti panduan ini akan membantu membuat kode Anda konsisten dengan aplikasi AWS CDK lainnya serta lebih mudah dipahami.
+ Gunakan`require()`, bukan `import` arahan ES6 -style. Versi Node.js yang lebih lama tidak mendukung ES6 impor, jadi menggunakan sintaks yang lebih lama lebih kompatibel secara luas. (Jika Anda benar-benar ingin menggunakan ES6 impor, gunakan [esm](https://www.npmjs.com/package/esm) untuk memastikan proyek Anda kompatibel dengan semua versi Node.js yang didukung.)
+ Umumnya, impor kelas individu dari`aws-cdk-lib`.
```
const { App, Stack } = require('aws-cdk-lib');
```
+ Jika Anda membutuhkan banyak kelas`aws-cdk-lib`, Anda dapat menggunakan alias namespace `cdk` alih-alih mengimpor kelas individual. Hindari melakukan keduanya.
```
const cdk = require('aws-cdk-lib');
```
+ Umumnya, impor AWS Construct Libraries menggunakan alias namespace pendek.
```
const { s3 } = require('aws-cdk-lib/aws-s3');
```
## Mengelola dependensi di JavaScript
Dalam proyek JavaScript CDK, dependensi ditentukan dalam `package.json` file di direktori utama proyek. Modul AWS CDK inti berada dalam satu `NPM` paket yang disebut`aws-cdk-lib`.
Saat Anda menginstal paket menggunakan`npm install`, NPM mencatat paket `package.json` untuk Anda.
Jika mau, Anda dapat menggunakan Benang sebagai pengganti NPM. Namun, CDK tidak mendukung plug-and-play mode Yarn, yang merupakan mode default di Yarn 2. Tambahkan berikut ini ke `.yarnrc.yml` file proyek Anda untuk mematikan fitur ini.
```
nodeLinker: node-modules
```
### Aplikasi CDK
Berikut ini adalah contoh `package.json` file yang dihasilkan oleh `cdk init --language typescript` perintah. File yang JavaScript dihasilkan untuk serupa, hanya tanpa entri TypeScript terkait.
```
{
"name": "my-package",
"version": "0.1.0",
"bin": {
"my-package": "bin/my-package.js"
},
"scripts": {
"build": "tsc",
"watch": "tsc -w",
"test": "jest",
"cdk": "cdk"
},
"devDependencies": {
"@types/jest": "^26.0.10",
"@types/node": "10.17.27",
"jest": "^26.4.2",
"ts-jest": "^26.2.0",
"aws-cdk": "2.16.0",
"ts-node": "^9.0.0",
"typescript": "~3.9.7"
},
"dependencies": {
"aws-cdk-lib": "2.16.0",
"constructs": "^10.0.0",
"source-map-support": "^0.5.16"
}
}
```
Untuk aplikasi CDK yang dapat di-deploy, `aws-cdk-lib` harus ditentukan di bagian. `dependencies` `package.json` Anda dapat menggunakan penentu nomor versi tanda sisipan (^) untuk menunjukkan bahwa Anda akan menerima versi yang lebih baru dari yang ditentukan selama mereka berada dalam versi utama yang sama.
Untuk konstruksi eksperimental, tentukan versi yang tepat untuk modul pustaka konstruksi alfa, APIs yang mungkin berubah. Jangan gunakan ^ atau \$1 karena versi modul ini yang lebih baru dapat membawa perubahan API yang dapat merusak aplikasi Anda.
Tentukan versi pustaka dan alat yang diperlukan untuk menguji aplikasi Anda (misalnya, kerangka `jest` pengujian) di `devDependencies` bagian. `package.json` Secara opsional, gunakan ^ untuk menentukan bahwa versi yang kompatibel selanjutnya dapat diterima.
### Perpustakaan konstruksi pihak ketiga
Jika Anda mengembangkan pustaka konstruksi, tentukan dependensinya menggunakan kombinasi `devDependencies` bagian `peerDependencies` dan, seperti yang ditunjukkan pada file contoh berikut. `package.json`
```
{
"name": "my-package",
"version": "0.0.1",
"peerDependencies": {
"aws-cdk-lib": "^2.14.0",
"@aws-cdk/aws-appsync-alpha": "2.10.0-alpha",
"constructs": "^10.0.0"
},
"devDependencies": {
"aws-cdk-lib": "2.14.0",
"@aws-cdk/aws-appsync-alpha": "2.10.0-alpha",
"constructs": "10.0.0",
"jsii": "^1.50.0",
"aws-cdk": "^2.14.0"
}
}
```
Di`peerDependencies`, gunakan tanda sisipan (^) untuk menentukan versi terendah `aws-cdk-lib` yang digunakan perpustakaan Anda. Ini memaksimalkan kompatibilitas perpustakaan Anda dengan berbagai versi CDK. Tentukan versi yang tepat untuk modul pustaka konstruksi alfa, APIs yang mungkin berubah. Menggunakan `peerDependencies` memastikan bahwa hanya ada satu salinan dari semua perpustakaan CDK di pohon. `node_modules`
Di`devDependencies`, tentukan alat dan pustaka yang Anda butuhkan untuk pengujian, secara opsional dengan ^ untuk menunjukkan bahwa versi kompatibel yang lebih baru dapat diterima. Tentukan dengan tepat (tanpa ^ atau \$1) versi terendah `aws-cdk-lib` dan paket CDK lainnya yang kompatibel dengan perpustakaan Anda. Praktik ini memastikan bahwa pengujian Anda berjalan terhadap versi tersebut. Dengan cara ini, jika Anda secara tidak sengaja menggunakan fitur yang hanya ditemukan di versi yang lebih baru, pengujian Anda dapat menangkapnya.
**Awas**
`peerDependencies`diinstal secara otomatis hanya oleh NPM 7 dan yang lebih baru. Jika Anda menggunakan NPM 6 atau sebelumnya, atau jika Anda menggunakan Yarn, Anda harus menyertakan dependensi dependensi Anda di. `devDependencies` Jika tidak, mereka tidak akan diinstal, dan Anda akan menerima peringatan tentang dependensi rekan yang belum terselesaikan.
### Menginstal dan memperbarui dependensi
Jalankan perintah berikut untuk menginstal dependensi proyek Anda.
**Example**
```
# Install the latest version of everything that matches the ranges in 'package.json'
npm install
# Install the same exact dependency versions as recorded in 'package-lock.json'
npm ci
```
```
# Install the latest version of everything that matches the ranges in 'package.json'
yarn upgrade
# Install the same exact dependency versions as recorded in 'yarn.lock'
yarn install --frozen-lockfile
```
Untuk memperbarui modul yang diinstal, `yarn upgrade` perintah sebelumnya `npm install` dan dapat digunakan. Perintah mana pun memperbarui paket `node_modules` ke versi terbaru yang memenuhi aturan di`package.json`. Namun, mereka tidak memperbarui `package.json` dirinya sendiri, yang mungkin ingin Anda lakukan untuk menetapkan versi minimum baru. Jika Anda meng-host paket Anda GitHub, Anda dapat mengonfigurasi [pembaruan versi Dependabot untuk memperbarui](https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/configuring-dependabot-version-updates) secara otomatis. `package.json` Alternatif lainnya, gunakan [npm-check-updates](https://www.npmjs.com/package/npm-check-updates).
**penting**
Secara desain, ketika Anda menginstal atau memperbarui dependensi, NPM dan Yarn memilih versi terbaru dari setiap paket yang memenuhi persyaratan yang ditentukan dalam. `package.json` Selalu ada risiko bahwa versi ini dapat rusak (baik secara tidak sengaja atau sengaja). Uji secara menyeluruh setelah memperbarui dependensi proyek Anda.
## AWS Idiom CDK di JavaScript
### Alat Peraga
Semua kelas AWS Construct Library dipakai menggunakan tiga argumen: *lingkup* di mana konstruksi sedang didefinisikan (induknya di pohon konstruksi), *id*, dan *props*, bundel key/value pasangan yang digunakan konstruksi untuk mengkonfigurasi sumber daya yang dibuatnya. AWS Kelas dan metode lain juga menggunakan pola “bundel atribut” untuk argumen.
Menggunakan IDE atau editor yang memiliki JavaScript pelengkapan otomatis yang baik akan membantu menghindari salah eja nama properti. Jika sebuah konstruksi mengharapkan `encryptionKeys` properti, dan Anda mengejanya, saat membuat instance konstruksi`encryptionkeys`, Anda belum melewati nilai yang Anda inginkan. Ini dapat menyebabkan kesalahan pada waktu sintesis jika properti diperlukan, atau menyebabkan properti diabaikan secara diam-diam jika bersifat opsional. Dalam kasus terakhir, Anda mungkin mendapatkan perilaku default yang ingin Anda timpa. Berhati-hatilah di sini.
Saat mensubklasifikasikan class AWS Construct Library (atau mengganti metode yang menggunakan argumen seperti props), Anda mungkin ingin menerima properti tambahan untuk Anda gunakan sendiri. Nilai-nilai ini akan diabaikan oleh kelas induk atau metode overridden, karena mereka tidak pernah diakses dalam kode itu, sehingga Anda umumnya dapat meneruskan semua props yang Anda terima.
Rilis AWS CDK di masa depan secara kebetulan dapat menambahkan properti baru dengan nama yang Anda gunakan untuk properti Anda sendiri. Melewati nilai yang Anda terima ke rantai pewarisan kemudian dapat menyebabkan perilaku yang tidak terduga. Lebih aman untuk meneruskan salinan dangkal alat peraga yang Anda terima dengan properti Anda dihapus atau disetel ke`undefined`. Contoh:
```
super(scope, name, {...props, encryptionKeys: undefined});
```
Atau, beri nama properti Anda sehingga jelas bahwa mereka milik konstruksi Anda. Dengan cara ini, kecil kemungkinan mereka akan bertabrakan dengan properti di rilis AWS CDK masa depan. Jika ada banyak dari mereka, gunakan satu objek dengan nama yang tepat untuk menahannya.
### Nilai yang hilang
Nilai yang hilang dalam suatu objek (seperti`props`) memiliki nilai `undefined` dalam JavaScript. Teknik yang biasa berlaku untuk menangani ini. Misalnya, idiom umum untuk mengakses properti dari nilai yang mungkin tidak terdefinisi adalah sebagai berikut:
```
// a may be undefined, but if it is not, it may have an attribute b
// c is undefined if a is undefined, OR if a doesn't have an attribute b
let c = a && a.b;
```
Namun, jika `a` bisa memiliki nilai “palsu” lain selain itu`undefined`, lebih baik membuat tes lebih eksplisit. Di sini, kita akan memanfaatkan fakta bahwa `null` dan `undefined` sama dengan menguji keduanya sekaligus:
```
let c = a == null ? a : a.b;
```
**Tip**
Node.js 14.0 dan yang lebih baru mendukung operator baru yang dapat menyederhanakan penanganan nilai yang tidak ditentukan. Untuk informasi lebih lanjut, lihat proposal [chaining opsional](https://github.com/tc39/proposal-optional-chaining/blob/master/README.md) dan [nullish](https://github.com/tc39/proposal-nullish-coalescing/blob/master/README.md) coalescing.
## Menggunakan TypeScript contoh dengan JavaScript
[TypeScript](https://www.typescriptlang.org/)adalah bahasa yang kami gunakan untuk mengembangkan AWS CDK, dan itu adalah bahasa pertama yang didukung untuk mengembangkan aplikasi, begitu banyak contoh kode AWS CDK yang tersedia ditulis. TypeScript Contoh kode ini dapat menjadi sumber daya yang baik untuk JavaScript pengembang; Anda hanya perlu menghapus bagian-bagian kode yang TypeScript spesifik.
TypeScript cuplikan sering menggunakan yang lebih baru ECMAScript `import` dan `export` kata kunci untuk mengimpor objek dari modul lain dan untuk mendeklarasikan objek yang akan tersedia di luar modul saat ini. Node.js baru saja mulai mendukung kata kunci ini dalam rilis terbarunya. Bergantung pada versi Node.js yang Anda gunakan (atau ingin mendukung), Anda dapat menulis ulang impor dan ekspor untuk menggunakan sintaks yang lebih lama.
Impor dapat diganti dengan panggilan ke `require()` fungsi.
**Example**
```
import * as cdk from 'aws-cdk-lib';
import { Bucket, BucketPolicy } from 'aws-cdk-lib/aws-s3';
```
```
const cdk = require('aws-cdk-lib');
const { Bucket, BucketPolicy } = require('aws-cdk-lib/aws-s3');
```
Ekspor dapat ditugaskan ke `module.exports` objek.
**Example**
```
export class Stack1 extends cdk.Stack {
// ...
}
export class Stack2 extends cdk.Stack {
// ...
}
```
```
class Stack1 extends cdk.Stack {
// ...
}
class Stack2 extends cdk.Stack {
// ...
}
module.exports = { Stack1, Stack2 }
```
**catatan**
[Alternatif untuk menggunakan impor dan ekspor gaya lama adalah dengan menggunakan modul esm.](https://www.npmjs.com/package/esm)
Setelah impor dan ekspor diurutkan, Anda dapat menggali kode yang sebenarnya. Anda mungkin mengalami fitur yang umum digunakan ini TypeScript :
+ Jenis anotasi
+ Definisi antarmuka
+ Jenis konversi/gips
+ Pengubah akses
Jenis anotasi dapat disediakan untuk variabel, anggota kelas, parameter fungsi, dan tipe pengembalian fungsi. Untuk variabel, parameter, dan anggota, jenis ditentukan dengan mengikuti pengidentifikasi dengan titik dua dan tipe. Nilai pengembalian fungsi mengikuti tanda tangan fungsi dan terdiri dari titik dua dan tipe.
Untuk mengonversi kode beranotasi tipe menjadi JavaScript, hapus titik dua dan jenisnya. Anggota kelas harus memiliki beberapa nilai JavaScript; atur mereka ke `undefined` jika mereka hanya memiliki anotasi tipe di TypeScript.
**Example**
```
var encrypted: boolean = true;
class myStack extends cdk.Stack {
bucket: s3.Bucket;
// ...
}
function makeEnv(account: string, region: string) : object {
// ...
}
```
```
var encrypted = true;
class myStack extends cdk.Stack {
bucket = undefined;
// ...
}
function makeEnv(account, region) {
// ...
}
```
Dalam TypeScript, antarmuka digunakan untuk memberikan bundel properti wajib dan opsional, dan jenisnya, nama. Anda kemudian dapat menggunakan nama antarmuka sebagai anotasi tipe. TypeScript akan memastikan bahwa objek yang Anda gunakan sebagai, misalnya, argumen ke fungsi memiliki properti yang diperlukan dari tipe yang tepat.
```
interface myFuncProps {
code: lambda.Code,
handler?: string
}
```
JavaScript tidak memiliki fitur antarmuka, jadi setelah Anda menghapus anotasi tipe, hapus deklarasi antarmuka sepenuhnya.
Ketika fungsi atau metode mengembalikan tipe tujuan umum (seperti`object`), tetapi Anda ingin memperlakukan nilai itu sebagai tipe anak yang lebih spesifik untuk mengakses properti atau metode yang bukan bagian dari antarmuka tipe yang lebih umum, TypeScript memungkinkan Anda *mentransmisikan* nilai menggunakan `as` diikuti oleh jenis atau nama antarmuka. JavaScript tidak mendukung (atau membutuhkan) ini, jadi cukup hapus `as` dan pengenal berikut. Sintaks cast yang kurang umum adalah menggunakan nama tipe dalam tanda kurung,``; gips ini juga harus dihapus.
Akhirnya, TypeScript mendukung pengubah akses`public`,`protected`, dan `private` untuk anggota kelas. Semua anggota kelas JavaScript adalah publik. Cukup hapus pengubah ini di mana pun Anda melihatnya.
Mengetahui cara mengidentifikasi dan menghapus TypeScript fitur-fitur ini sangat membantu mengadaptasi TypeScript cuplikan pendek. JavaScript Tetapi mungkin tidak praktis untuk mengonversi TypeScript contoh yang lebih panjang dengan cara ini, karena mereka lebih cenderung menggunakan TypeScript fitur lain. Untuk situasi ini, kami merekomendasikan [Sucrase](https://github.com/alangpierce/sucrase). Sucrase tidak akan mengeluh jika kode menggunakan variabel yang tidak ditentukan, misalnya, seperti yang akan terjadi. `tsc` Jika valid secara sintaksis, maka dengan beberapa pengecualian, Sucrase dapat menerjemahkannya ke. JavaScript Ini membuatnya sangat berharga untuk mengonversi cuplikan yang mungkin tidak dapat dijalankan sendiri.
## Migrasi ke TypeScript
Banyak JavaScript pengembang pindah ke [TypeScript](https://www.typescriptlang.org/)proyek mereka menjadi lebih besar dan lebih kompleks. TypeScript adalah superset dari JavaScript —semua JavaScript kode adalah kode yang valid, jadi tidak ada perubahan pada TypeScript kode Anda yang diperlukan—dan ini juga merupakan bahasa CDK yang didukung. AWS Jenis anotasi dan TypeScript fitur lainnya bersifat opsional dan dapat ditambahkan ke aplikasi AWS CDK Anda saat Anda menemukan nilai di dalamnya. TypeScript juga memberi Anda akses awal ke JavaScript fitur-fitur baru, seperti rantai opsional dan penggabungan nullish, sebelum selesai — dan tanpa mengharuskan Anda meningkatkan Node.js.
TypeScriptantarmuka “berbasis bentuk”, yang mendefinisikan bundel properti wajib dan opsional (dan jenisnya) dalam suatu objek, memungkinkan kesalahan umum ditangkap saat Anda menulis kode, dan memudahkan IDE Anda untuk memberikan pelengkapan otomatis yang kuat dan saran pengkodean waktu nyata lainnya.
Coding in TypeScript memang melibatkan langkah tambahan: mengompilasi aplikasi Anda dengan TypeScript compiler,. `tsc` Untuk aplikasi AWS CDK biasa, kompilasi membutuhkan waktu paling lama beberapa detik.
Cara termudah untuk memigrasikan aplikasi JavaScript AWS CDK yang ada TypeScript adalah dengan membuat TypeScript proyek baru menggunakan`cdk init app --language typescript`, lalu salin file sumber Anda (dan file lain yang diperlukan, seperti aset seperti kode sumber fungsi AWS Lambda) ke proyek baru. Ganti nama JavaScript file Anda untuk mengakhiri `.ts` dan mulai mengembangkan. TypeScript
# Bekerja dengan AWS CDK dengan Python
Python adalah bahasa klien yang sepenuhnya didukung untuk AWS Cloud Development Kit (AWS CDK) dan dianggap stabil. Bekerja dengan AWS CDK di Python menggunakan alat yang sudah dikenal, termasuk implementasi Python standar CPython (), lingkungan virtual dengan`virtualenv`, dan penginstal paket Python. `pip` [Modul yang terdiri dari AWS Construct Library didistribusikan melalui pypi.org.](https://pypi.org/search/?q=aws-cdk) Versi Python dari AWS CDK bahkan menggunakan pengidentifikasi gaya Python (misalnya, nama metode). `snake_case`
Anda dapat menggunakan editor atau IDE apa pun. [Banyak pengembang AWS CDK menggunakan [Visual Studio Code](https://code.visualstudio.com/) (atau padanan open-source [VSCodium](https://vscodium.com/)), yang memiliki dukungan yang baik untuk Python melalui ekstensi resmi.](https://marketplace.visualstudio.com/items?itemName=ms-python.python) Editor IDLE yang disertakan dengan Python sudah cukup untuk memulai. Modul Python untuk AWS CDK memang memiliki petunjuk tipe, yang berguna untuk alat linting atau IDE yang mendukung validasi tipe.
## Memulai dengan Python
Untuk bekerja dengan AWS CDK, Anda harus memiliki AWS akun dan kredensil dan telah menginstal Node.js dan CDK Toolkit. AWS Lihat [Memulai dengan AWS CDK](getting-started.md).
Aplikasi AWS CDK Python membutuhkan Python 3.9 atau yang lebih baru. Jika Anda belum menginstalnya, [unduh versi yang kompatibel](https://www.python.org/downloads/) untuk sistem operasi Anda di [python.org](https://www.python.org/). Jika Anda menjalankan Linux, sistem Anda mungkin datang dengan versi yang kompatibel, atau Anda dapat menginstalnya menggunakan manajer paket distro Anda (`yum`,`apt`, dll.). Pengguna Mac mungkin tertarik dengan [Homebrew](https://brew.sh/), pengelola paket bergaya Linux untuk macOS.
**catatan**
Pengakhiran bahasa pihak ketiga: versi bahasa hanya didukung hingga EOL (End Of Life) dibagikan oleh vendor atau komunitas dan dapat berubah sewaktu-waktu dengan pemberitahuan sebelumnya.
Penginstal paket Python,`pip`, dan manajer lingkungan virtual`virtualenv`, juga diperlukan. Instalasi Windows dari versi Python yang kompatibel termasuk alat-alat ini. Di Linux, `pip` dan `virtualenv` dapat disediakan sebagai paket terpisah di manajer paket Anda. Atau, Anda dapat menginstalnya dengan perintah berikut:
```
python -m ensurepip --upgrade
python -m pip install --upgrade pip
python -m pip install --upgrade virtualenv
```
Jika Anda mengalami kesalahan izin, jalankan perintah di atas dengan `--user` bendera sehingga modul diinstal di direktori pengguna Anda, atau gunakan `sudo` untuk mendapatkan izin untuk menginstal modul di seluruh sistem.
**catatan**
Hal ini umum untuk distro Linux untuk menggunakan nama executable untuk `python3` Python 3.x, dan telah merujuk `python` ke instalasi Python 2.x. Beberapa distro memiliki paket opsional yang dapat Anda instal yang membuat `python` perintah mengacu pada Python 3. Jika gagal, Anda dapat menyesuaikan perintah yang digunakan untuk menjalankan aplikasi Anda dengan mengedit `cdk.json` di direktori utama proyek.
**catatan**
Di Windows, Anda mungkin ingin memanggil Python (`pip`dan) menggunakan executable, `py` peluncur [Python untuk](https://docs.python.org/3/using/windows.html#launcher) Windows. Antara lain, peluncur memungkinkan Anda untuk dengan mudah menentukan versi Python yang diinstal yang ingin Anda gunakan.
Jika mengetik `python` di baris perintah menghasilkan pesan tentang menginstal Python dari Windows Store, bahkan setelah menginstal Python versi Windows, buka panel pengaturan Alias Eksekusi Aplikasi Windows dan matikan dua entri Penginstal Aplikasi untuk Python.
## Membuat proyek
Anda membuat proyek AWS CDK baru dengan memanggil `cdk init` di direktori kosong. Gunakan `--language` opsi dan tentukan`python`:
```
$ mkdir my-project
$ cd my-project
$ cdk init app --language python
```
`cdk init`menggunakan nama folder proyek untuk memberi nama berbagai elemen proyek, termasuk kelas, subfolder, dan file. Tanda hubung dalam nama folder diubah menjadi garis bawah. Namun, nama tersebut harus mengikuti bentuk pengenal Python; misalnya, seharusnya tidak dimulai dengan angka atau berisi spasi.
Untuk bekerja dengan proyek baru, aktifkan lingkungan virtualnya. Ini memungkinkan dependensi proyek diinstal secara lokal di folder proyek, bukan secara global.
```
$ source .venv/bin/activate
```
**catatan**
Anda mungkin mengenali ini sebagai Mac/Linux perintah untuk mengaktifkan lingkungan virtual. Templat Python menyertakan file batch, `source.bat`, yang memungkinkan perintah yang sama untuk digunakan pada Windows. Perintah Windows tradisional juga berfungsi. `.\venv\Scripts\activate`
Jika Anda menginisialisasi proyek AWS CDK Anda menggunakan CDK Toolkit v1.70.0 atau yang lebih lama, lingkungan virtual Anda ada di direktori, bukan. `.env` `.venv`
**penting**
Aktifkan lingkungan virtual proyek setiap kali Anda mulai mengerjakannya. Jika tidak, Anda tidak akan memiliki akses ke modul yang diinstal di sana, dan modul yang Anda instal akan masuk ke direktori modul global Python (atau akan menghasilkan kesalahan izin).
Setelah mengaktifkan lingkungan virtual Anda untuk pertama kalinya, instal dependensi standar aplikasi:
```
$ python -m pip install -r requirements.txt
```
## Mengelola AWS modul Construct Library
Gunakan penginstal paket Python,`pip`, untuk menginstal dan memperbarui modul AWS Construct Library untuk digunakan oleh aplikasi Anda, serta paket lain yang Anda butuhkan. `pip`juga menginstal dependensi untuk modul-modul tersebut secara otomatis. Jika sistem Anda tidak mengenali `pip` sebagai perintah mandiri, panggil `pip` sebagai modul Python, seperti ini:
```
$ python -m pip
```
Sebagian besar konstruksi AWS CDK ada di. `aws-cdk-lib` Modul eksperimental berada dalam modul terpisah bernama like`aws-cdk..alpha`. Nama layanan menyertakan awalan *aws*. Jika Anda tidak yakin dengan nama modul, [cari di PyPI](https://pypi.org/search/?q=aws-cdk). Misalnya, perintah di bawah ini menginstal AWS CodeStar perpustakaan.
```
$ python -m pip install aws-cdk.aws-codestar-alpha
```
Beberapa konstruksi layanan berada di lebih dari satu namespace. Misalnya, selain itu`aws-cdk.aws-route53`, ada tiga ruang nama Amazon Route 53 tambahan, bernama `aws-route53-targets``aws-route53-patterns`, dan. `aws-route53resolver`
**catatan**
[Edisi Python dari Referensi API CDK](https://docs.aws.amazon.com/cdk/api/v2/python/index.html) juga menunjukkan nama paket.
Nama-nama yang digunakan untuk mengimpor modul AWS Construct Library ke dalam kode Python Anda terlihat seperti berikut ini.
```
import aws_cdk.aws_s3 as s3
import aws_cdk.aws_lambda as lambda_
```
Kami merekomendasikan praktik berikut saat mengimpor kelas AWS CDK dan modul AWS Construct Library di aplikasi Anda. Mengikuti panduan ini akan membantu membuat kode Anda konsisten dengan aplikasi AWS CDK lainnya serta lebih mudah dipahami.
+ Umumnya, impor kelas individu dari tingkat atas`aws_cdk`.
```
from aws_cdk import App, Construct
```
+ Jika Anda membutuhkan banyak kelas dari`aws_cdk`, Anda dapat menggunakan alias namespace `cdk` alih-alih mengimpor kelas individual. Hindari melakukan keduanya.
```
import aws_cdk as cdk
```
+ Umumnya, impor AWS Construct Libraries menggunakan alias namespace pendek.
```
import aws_cdk.aws_s3 as s3
```
Setelah menginstal modul, perbarui `requirements.txt` file proyek Anda, yang mencantumkan dependensi proyek Anda. Yang terbaik adalah melakukan ini secara manual daripada menggunakan`pip freeze`. `pip freeze`menangkap versi saat ini dari semua modul yang diinstal di lingkungan virtual Python Anda, yang dapat berguna saat menggabungkan proyek untuk dijalankan di tempat lain.
Namun, biasanya, Anda hanya `requirements.txt` boleh mencantumkan dependensi tingkat atas (modul yang bergantung langsung pada aplikasi Anda) dan bukan dependensi pustaka tersebut. Strategi ini membuat memperbarui dependensi Anda lebih sederhana.
Anda dapat mengedit `requirements.txt` untuk mengizinkan peningkatan; cukup ganti nomor versi `==` sebelumnya dengan `~=` untuk memungkinkan peningkatan ke versi kompatibel yang lebih tinggi, atau hapus persyaratan versi sepenuhnya untuk menentukan versi modul terbaru yang tersedia.
Dengan `requirements.txt` diedit dengan tepat untuk memungkinkan peningkatan, keluarkan perintah ini untuk memutakhirkan modul yang diinstal proyek Anda kapan saja:
```
$ pip install --upgrade -r requirements.txt
```
## Mengelola dependensi dengan Python
Dengan Python, Anda menentukan dependensi dengan memasukkannya ke dalam aplikasi atau `requirements.txt` `setup.py` untuk membangun perpustakaan. Dependensi kemudian dikelola dengan alat PIP. PIP dipanggil dengan salah satu cara berikut:
```
pip
python -m pip
```
`python -m pip`Pemanggilan bekerja pada sebagian besar sistem; `pip` mengharuskan PIP yang dapat dieksekusi berada di jalur sistem. Jika `pip` tidak berhasil, coba ganti dengan`python -m pip`.
`cdk init --language python`Perintah menciptakan lingkungan virtual untuk proyek baru Anda. Ini memungkinkan setiap proyek memiliki versi dependensi sendiri, dan juga file dasar`requirements.txt`. Anda harus mengaktifkan lingkungan virtual ini dengan menjalankan `source .venv/bin/activate` setiap kali Anda mulai bekerja dengan proyek. Di Windows, jalankan `.\venv\Scripts\activate` sebagai gantinya
### Aplikasi CDK
Berikut ini adalah contoh `requirements.txt` file. Karena PIP tidak memiliki fitur penguncian ketergantungan, kami menyarankan Anda menggunakan operator == untuk menentukan versi yang tepat untuk semua dependensi, seperti yang ditunjukkan di sini.
```
aws-cdk-lib==2.14.0
aws-cdk.aws-appsync-alpha==2.10.0a0
```
Menginstal modul dengan `pip install` tidak secara otomatis menambahkannya`requirements.txt`. Anda harus melakukannya sendiri. Jika Anda ingin meningkatkan ke versi dependensi yang lebih baru, edit nomor versinya di`requirements.txt`.
Untuk menginstal atau memperbarui dependensi proyek Anda setelah membuat atau mengedit`requirements.txt`, jalankan yang berikut:
```
python -m pip install -r requirements.txt
```
**Tip**
`pip freeze`Perintah mengeluarkan versi semua dependensi yang diinstal dalam format yang dapat ditulis ke file teks. Ini dapat digunakan sebagai file persyaratan dengan`pip install -r`. File ini nyaman untuk menyematkan semua dependensi (termasuk yang transitif) ke versi persis yang Anda uji. Untuk menghindari masalah saat memutakhirkan paket nanti, gunakan file terpisah untuk ini, seperti `freeze.txt` (not`requirements.txt`). Kemudian, buat ulang saat Anda memutakhirkan dependensi proyek Anda.
### Perpustakaan konstruksi pihak ketiga
Di pustaka, dependensi ditentukan dalam`setup.py`, sehingga dependensi transitif diunduh secara otomatis ketika paket dikonsumsi oleh aplikasi. Jika tidak, setiap aplikasi yang ingin menggunakan paket Anda perlu menyalin dependensi Anda ke dalamnya. `requirements.txt` Contoh `setup.py` ditampilkan di sini.
```
from setuptools import setup
setup(
name='my-package',
version='0.0.1',
install_requires=[
'aws-cdk-lib==2.14.0',
],
...
)
```
Untuk mengerjakan paket untuk pengembangan, buat atau aktifkan lingkungan virtual, lalu jalankan perintah berikut.
```
python -m pip install -e .
```
Meskipun PIP secara otomatis menginstal dependensi transitif, hanya ada satu salinan yang diinstal dari satu paket. Versi yang ditentukan tertinggi di pohon ketergantungan dipilih; aplikasi selalu memiliki kata terakhir dalam versi paket apa yang diinstal.
## AWS Idiom CDK dengan Python
### Konflik bahasa
Dalam Python, `lambda` adalah kata kunci bahasa, sehingga Anda tidak dapat menggunakannya sebagai nama untuk modul perpustakaan konstruksi Lambda atau AWS fungsi Lambda. Konvensi Python untuk konflik tersebut adalah dengan menggunakan garis bawah, seperti pada`lambda_`, dalam nama variabel.
Menurut konvensi, argumen kedua untuk konstruksi AWS CDK diberi nama. `id` Saat menulis tumpukan dan konstruksi Anda sendiri, memanggil parameter `id` “bayangan” fungsi bawaan Python`id()`, yang mengembalikan pengenal unik objek. Fungsi ini tidak sering digunakan, tetapi jika Anda membutuhkannya dalam konstruksi Anda, ganti nama argumen, misalnya. `construct_id`
### Argumen dan properti
Semua kelas AWS Construct Library dipakai menggunakan tiga argumen: *lingkup* di mana konstruksi sedang didefinisikan (induknya di pohon konstruksi), *id*, dan *props*, bundel key/value pasangan yang digunakan konstruksi untuk mengkonfigurasi sumber daya yang dibuatnya. Kelas dan metode lain juga menggunakan pola “bundel atribut” untuk argumen.
*scope* *dan *id* harus selalu diteruskan sebagai argumen posisi, bukan argumen kata kunci, karena namanya berubah jika konstruksi menerima properti bernama *scope* atau id.*
Dalam Python, props dinyatakan sebagai argumen kata kunci. Jika argumen berisi struktur data bersarang, ini diekspresikan menggunakan kelas yang mengambil argumen kata kunci sendiri di instantiation. Pola yang sama diterapkan pada panggilan metode lain yang mengambil argumen terstruktur.
Misalnya, dalam `add_lifecycle_rule` metode bucket Amazon S3, `transitions` properti adalah daftar instance. `Transition`
```
bucket.add_lifecycle_rule(
transitions=[
Transition(
storage_class=StorageClass.GLACIER,
transition_after=Duration.days(10)
)
]
)
```
Saat memperluas kelas atau mengganti metode, Anda mungkin ingin menerima argumen tambahan untuk tujuan Anda sendiri yang tidak dipahami oleh kelas induk. Dalam hal ini Anda harus menerima argumen yang tidak Anda pedulikan menggunakan idiom \$1\$1kwargs, dan menggunakan argumen khusus kata kunci untuk menerima argumen yang Anda minati. Saat memanggil konstruktor induk atau metode yang diganti, berikan hanya argumen yang diharapkannya (seringkali hanya \$1\$1 kwargs). Melewati argumen bahwa kelas induk atau metode tidak mengharapkan hasil kesalahan.
```
class MyConstruct(Construct):
def __init__(self, id, *, MyProperty=42, **kwargs):
super().__init__(self, id, **kwargs)
# ...
```
Rilis AWS CDK di masa depan secara kebetulan dapat menambahkan properti baru dengan nama yang Anda gunakan untuk properti Anda sendiri. Ini tidak akan menyebabkan masalah teknis apa pun bagi pengguna konstruksi atau metode Anda (karena properti Anda tidak melewati “rantai”, kelas induk atau metode yang diganti hanya akan menggunakan nilai default) tetapi dapat menyebabkan kebingungan. Anda dapat menghindari masalah potensial ini dengan memberi nama properti Anda sehingga mereka jelas milik konstruksi Anda. Jika ada banyak properti baru, bundel mereka ke dalam kelas yang diberi nama tepat dan meneruskannya sebagai argumen kata kunci tunggal.
### Nilai yang hilang
AWS CDK digunakan `None` untuk mewakili nilai yang hilang atau tidak ditentukan. Saat bekerja dengan\$1\$1kwargs, gunakan `get()` metode kamus untuk memberikan nilai default jika properti tidak disediakan. Hindari penggunaan`kwargs[…]`, karena ini menimbulkan nilai `KeyError` yang hilang.
```
encrypted = kwargs.get("encrypted") # None if no property "encrypted" exists
encrypted = kwargs.get("encrypted", False) # specify default of False if property is missing
```
Beberapa metode AWS CDK (seperti `tryGetContext()` untuk mendapatkan nilai konteks runtime) mungkin kembali`None`, yang perlu Anda periksa secara eksplisit.
### Menggunakan antarmuka
Python tidak memiliki fitur antarmuka seperti beberapa bahasa lain, meskipun memang memiliki [kelas dasar abstrak](https://docs.python.org/3/library/abc.html), yang serupa. (Jika Anda tidak terbiasa dengan antarmuka, Wikipedia memiliki [pengantar yang bagus](https://en.wikipedia.org/wiki/Interface_(computing)#In_object-oriented_languages).) TypeScript, bahasa di mana AWS CDK diimplementasikan, memang menyediakan antarmuka, dan konstruksi dan objek AWS CDK lainnya sering memerlukan objek yang melekat pada antarmuka tertentu, daripada mewarisi dari kelas tertentu. Jadi AWS CDK menyediakan fitur antarmuka sendiri sebagai bagian dari lapisan [JSII](https://github.com/aws/jsii).
Untuk menunjukkan bahwa kelas mengimplementasikan antarmuka tertentu, Anda dapat menggunakan `@jsii.implements` dekorator:
```
from aws_cdk import IAspect, IConstruct
import jsii
@jsii.implements(IAspect)
class MyAspect():
def visit(self, node: IConstruct) -> None:
print("Visited", node.node.path)
```
### Jenis jebakan
Python menggunakan pengetikan dinamis, di mana semua variabel dapat merujuk ke nilai jenis apa pun. Parameter dan nilai pengembalian dapat dianotasi dengan tipe, tetapi ini adalah “petunjuk” dan tidak diberlakukan. Ini berarti bahwa dengan Python, mudah untuk meneruskan jenis nilai yang salah ke konstruksi AWS CDK. Alih-alih mendapatkan kesalahan tipe selama pembuatan, seperti yang Anda lakukan dari bahasa yang diketik secara statis, Anda mungkin mendapatkan kesalahan runtime ketika lapisan JSII (yang menerjemahkan antara Python dan inti CDK TypeScript ) tidak dapat menangani tipe AWS yang tidak terduga.
Menurut pengalaman kami, kesalahan tipe yang dilakukan programmer Python cenderung masuk dalam kategori ini.
+ Melewati satu nilai di mana konstruksi mengharapkan wadah (daftar Python atau kamus) atau sebaliknya.
+ Melewati nilai tipe yang terkait dengan konstruksi layer 1 (`CfnXxxxxx`) ke konstruksi L2 atau L3, atau sebaliknya.
## Mencegah kesalahan tipe
Modul AWS CDK Python menyertakan anotasi tipe, sehingga Anda dapat menggunakan alat yang mendukungnya untuk menangkap kesalahan tipe sebelum penerapan.
### Integrasi IDE (disarankan)
Visual Studio Code dengan Pylance menyediakan pengecekan tipe real-time saat Anda menulis kode:
1. Instal ekstensi [Pylance](https://marketplace.visualstudio.com/items?itemName=ms-python.vscode-pylance)
1. Konfigurasikan pemeriksaan tipe ketat`.vscode/settings.json`:
```
{
"python.languageServer": "Pylance",
"python.analysis.typeCheckingMode": "strict"
}
```
1. Kesalahan ketik sekarang segera muncul dengan coretan merah dan pesan kesalahan terperinci
[PyCharm](https://www.jetbrains.com/pycharm/)juga menyediakan pemeriksaan tipe bawaan dengan kemampuan serupa.
### Pemeriksaan tipe baris perintah
Untuk CI/CD pipeline atau validasi pra-komit, gunakan salah satu dari jenis checker ini:
**MyPy (Berbasis Python):**
```
pip install mypy
mypy app.py
```
**Pyright (lebih cepat, JavaScript berbasis, mesin yang sama dengan Pylance):**
```
npm install -g pyright
pyright app.py
```
### Alur kerja yang direkomendasikan
1. Selama pengembangan: Gunakan Pyright atau Pylance untuk umpan balik instan
1. Sebelum komit: Jalankan `mypy app.py` atau `pyright app.py`
1. Dalam CI/CD: Jadikan pemeriksaan tipe sebagai langkah yang diperlukan sebelum penerapan
# Bekerja dengan AWS CDK di Jawa
Java adalah bahasa klien yang didukung penuh untuk AWS CDK dan dianggap stabil. Anda dapat mengembangkan aplikasi AWS CDK di Java menggunakan alat yang sudah dikenal, termasuk JDK (Oracle's, atau distribusi OpenJDK seperti Amazon Corretto) dan Apache Maven.
AWS CDK mendukung Java 8 dan yang lebih baru. Kami merekomendasikan untuk menggunakan versi terbaru yang Anda bisa, karena versi bahasa yang lebih baru mencakup peningkatan yang sangat nyaman untuk mengembangkan aplikasi AWS CDK. Misalnya, Java 9 memperkenalkan `Map.of()` metode (cara mudah untuk mendeklarasikan hashmap yang akan ditulis sebagai literal objek). TypeScript Java 10 memperkenalkan inferensi tipe lokal menggunakan kata kunci. `var`
**catatan**
Sebagian besar contoh kode dalam Panduan Pengembang ini bekerja dengan Java 8. Beberapa contoh digunakan`Map.of()`; contoh-contoh ini termasuk komentar yang mencatat bahwa mereka memerlukan Java 9.
Anda dapat menggunakan editor teks apa pun, atau IDE Java yang dapat membaca proyek Maven, untuk bekerja pada aplikasi AWS CDK Anda. Kami menyediakan petunjuk [Eclipse](https://www.eclipse.org/downloads/) dalam Panduan ini, tetapi IntelliJ IDEA, NetBeans, dan lainnya IDEs dapat mengimpor proyek Maven dan dapat digunakan untuk mengembangkan aplikasi CDK di Jawa. AWS
Dimungkinkan untuk menulis aplikasi AWS CDK dalam bahasa yang dihosting JVM selain Java (misalnya, Kotlin, Groovy, Clojure, atau Scala), tetapi pengalamannya mungkin tidak terlalu idiomatis, dan kami tidak dapat memberikan dukungan apa pun untuk bahasa-bahasa ini.
## Memulai Java
Untuk bekerja dengan AWS CDK, Anda harus memiliki AWS akun dan kredensil dan telah menginstal Node.js dan CDK Toolkit. AWS Lihat [Memulai dengan AWS CDK](getting-started.md).
Aplikasi AWS CDK Java memerlukan Java 8 (v1.8) atau yang lebih baru. [Kami merekomendasikan [Amazon Corretto](https://aws.amazon.com/corretto/), tetapi Anda dapat menggunakan distribusi OpenJDK atau JDK Oracle.](https://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html) Anda juga membutuhkan [Apache Maven](https://maven.apache.org/download.cgi) 3.5 atau yang lebih baru. Anda juga dapat menggunakan alat seperti Gradle, tetapi kerangka aplikasi yang dihasilkan oleh AWS CDK Toolkit adalah proyek Maven.
**catatan**
Pengakhiran bahasa pihak ketiga: versi bahasa hanya didukung hingga EOL (End Of Life) dibagikan oleh vendor atau komunitas dan dapat berubah sewaktu-waktu dengan pemberitahuan sebelumnya.
## Membuat proyek
Anda membuat proyek AWS CDK baru dengan memanggil `cdk init` di direktori kosong. Gunakan `--language` opsi dan tentukan`java`:
```
$ mkdir my-project
$ cd my-project
$ cdk init app --language java
```
`cdk init`menggunakan nama folder proyek untuk memberi nama berbagai elemen proyek, termasuk kelas, subfolder, dan file. Tanda hubung dalam nama folder diubah menjadi garis bawah. Namun, nama tersebut harus mengikuti bentuk pengenal Java; misalnya, seharusnya tidak dimulai dengan angka atau berisi spasi.
Proyek yang dihasilkan mencakup referensi ke paket `software.amazon.awscdk` Maven. Ini dan dependensinya diinstal secara otomatis oleh Maven.
Jika Anda menggunakan IDE, Anda sekarang dapat membuka atau mengimpor proyek. **Di Eclipse, misalnya, pilih **File** > **Import > Maven > Existing** **Maven Projects**.** Pastikan bahwa pengaturan proyek diatur untuk menggunakan Java 8 (1.8).
## Mengelola AWS modul Construct Library
Gunakan Maven untuk menginstal paket AWS Construct Library, yang ada di grup. `software.amazon.awscdk` Sebagian besar konstruksi berada di artefak`aws-cdk-lib`, yang ditambahkan ke proyek Java baru secara default. Modul untuk layanan yang dukungan CDK tingkat tinggi masih dikembangkan berada dalam paket “eksperimental” terpisah, dinamai dengan versi pendek (tidak ada atau awalan AWS Amazon) dari nama layanan mereka. [Cari Repositori Pusat Maven](https://search.maven.org/search?q=software.amazon.awscdk) untuk menemukan nama semua perpustakaan AWS CDK dan Construct Module. AWS
**catatan**
[Edisi Java dari Referensi API CDK](https://docs.aws.amazon.com/cdk/api/v2/java/index.html) juga menunjukkan nama paket.
Dukungan AWS Construct Library beberapa layanan ada di lebih dari satu namespace. Misalnya, Amazon Route 53 memiliki fungsinya dibagi menjadi`software.amazon.awscdk.route53`,`route53-patterns`,`route53resolver`, dan`route53-targets`.
Paket AWS CDK utama diimpor dalam kode Java sebagai`software.amazon.awscdk`. Modul untuk berbagai layanan di Perpustakaan AWS Konstruksi hidup di bawah `software.amazon.awscdk.services` dan diberi nama yang mirip dengan nama paket Maven mereka. Misalnya, namespace modul Amazon S3 adalah. `software.amazon.awscdk.services.s3`
Sebaiknya tulis `import` pernyataan Java terpisah untuk setiap kelas AWS Construct Library yang Anda gunakan di setiap file sumber Java Anda, dan menghindari impor wildcard. Anda selalu dapat menggunakan nama tipe yang sepenuhnya memenuhi syarat (termasuk namespace-nya) tanpa pernyataan. `import`
Jika aplikasi Anda bergantung pada paket eksperimental, edit proyek Anda `pom.xml` dan tambahkan `` elemen baru dalam `` wadah. Misalnya, `` elemen berikut menentukan modul pustaka konstruksi CodeStar eksperimental:
```
software.amazon.awscdkcodestar-alpha2.0.0-alpha.10
```
**Tip**
Jika Anda menggunakan IDE Java, mungkin memiliki fitur untuk mengelola dependensi Maven. Namun, kami merekomendasikan untuk mengedit `pom.xml` secara langsung, kecuali Anda benar-benar yakin fungsionalitas IDE cocok dengan apa yang akan Anda lakukan dengan tangan.
## Mengelola dependensi di Java
Di Java, dependensi ditentukan `pom.xml` dan diinstal menggunakan Maven. ``Wadah mencakup `` elemen untuk setiap paket. Berikut ini adalah bagian dari `pom.xml` untuk aplikasi CDK Java yang khas.
```
software.amazon.awscdkaws-cdk-lib2.14.0software.amazon.awscdkappsync-alpha2.10.0-alpha.0
```
**Tip**
Banyak Java IDEs telah mengintegrasikan dukungan Maven dan `pom.xml` editor visual, yang mungkin Anda temukan nyaman untuk mengelola dependensi.
Maven tidak mendukung penguncian ketergantungan. Meskipun dimungkinkan untuk menentukan rentang versi`pom.xml`, kami sarankan Anda selalu menggunakan versi yang tepat agar build Anda tetap dapat diulang.
Maven secara otomatis menginstal dependensi transitif, tetapi hanya ada satu salinan yang diinstal dari setiap paket. Versi yang ditentukan tertinggi di pohon POM dipilih; aplikasi selalu memiliki kata terakhir dalam versi paket apa yang diinstal.
Maven secara otomatis menginstal atau memperbarui dependensi Anda setiap kali Anda membangun (`mvn compile`) atau package () proyek Anda. `mvn package` CDK Toolkit melakukan ini secara otomatis setiap kali Anda menjalankannya, jadi umumnya tidak perlu memanggil Maven secara manual.
## AWS Idiom CDK di Jawa
### Alat Peraga
Semua kelas AWS Construct Library dipakai menggunakan tiga argumen: *lingkup* di mana konstruksi sedang didefinisikan (induknya di pohon konstruksi), *id*, dan *props*, bundel key/value pasangan yang digunakan konstruksi untuk mengkonfigurasi sumber daya yang dibuatnya. Kelas dan metode lain juga menggunakan pola “bundel atribut” untuk argumen.
Di Jawa, alat peraga diekspresikan menggunakan [pola Builder](https://en.wikipedia.org/wiki/Builder_pattern). Setiap tipe konstruksi memiliki tipe props yang sesuai; misalnya, `Bucket` konstruksi (yang mewakili bucket Amazon S3) mengambil sebagai props sebagai instance dari. `BucketProps`
`BucketProps`Kelas (seperti setiap kelas props AWS Construct Library) memiliki kelas dalam yang disebut. `Builder` `BucketProps.Builder`Jenis ini menawarkan metode untuk mengatur berbagai properti dari sebuah `BucketProps` instance. Setiap metode mengembalikan `Builder` instance, sehingga panggilan metode dapat dirantai untuk mengatur beberapa properti. Di akhir rantai, Anda memanggil `build()` untuk benar-benar menghasilkan `BucketProps` objek.
```
Bucket bucket = new Bucket(this, "amzn-s3-demo-bucket", new BucketProps.Builder()
.versioned(true)
.encryption(BucketEncryption.KMS_MANAGED)
.build());
```
Konstruksi, dan kelas lain yang mengambil objek seperti alat peraga sebagai argumen terakhir mereka, menawarkan jalan pintas. Kelas memiliki sendiri `Builder` yang membuat instance dan objek props dalam satu langkah. Dengan cara ini, Anda tidak perlu secara eksplisit membuat instance (misalnya) keduanya `BucketProps` dan `Bucket` --dan Anda tidak memerlukan impor untuk jenis alat peraga.
```
Bucket bucket = Bucket.Builder.create(this, "amzn-s3-demo-bucket")
.versioned(true)
.encryption(BucketEncryption.KMS_MANAGED)
.build();
```
Saat menurunkan konstruksi Anda sendiri dari konstruksi yang ada, Anda mungkin ingin menerima properti tambahan. Kami menyarankan Anda mengikuti pola pembangun ini. Namun, ini tidak sesederhana mensubklasifikasikan kelas konstruksi. Anda harus menyediakan sendiri bagian yang bergerak dari dua `Builder` kelas baru. Anda mungkin lebih suka membuat konstruksi Anda menerima satu atau lebih argumen tambahan. Anda harus memberikan konstruktor tambahan ketika argumen bersifat opsional.
### Struktur generik
Dalam beberapa APIs, AWS CDK menggunakan JavaScript array atau objek yang tidak diketik sebagai input ke metode. (Lihat, misalnya, AWS CodeBuild [https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_codebuild.BuildSpec.html#static-fromwbrobjectvalue](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_codebuild.BuildSpec.html#static-fromwbrobjectvalue)metode.) Di Jawa, objek-objek ini direpresentasikan sebagai`java.util.Map`. Dalam kasus di mana nilai-nilai semua string, Anda dapat menggunakan`Map`.
Java tidak menyediakan cara untuk menulis literal untuk wadah seperti yang dilakukan beberapa bahasa lain. Di Java 9 dan yang lebih baru, Anda dapat menggunakan [https://docs.oracle.com/javase/9/docs/api/java/util/Map.html#ofEntries-java.util.Map.Entry…-](https://docs.oracle.com/javase/9/docs/api/java/util/Map.html#ofEntries-java.util.Map.Entry…-)untuk dengan mudah menentukan peta hingga sepuluh entri sebaris dengan salah satu panggilan ini.
```
java.util.Map.of(
"base-directory", "dist",
"files", "LambdaStack.template.json"
)
```
Untuk membuat peta dengan lebih dari sepuluh entri, gunakan [https://docs.oracle.com/javase/9/docs/api/java/util/Map.html#ofEntries-java.util.Map.Entry…-](https://docs.oracle.com/javase/9/docs/api/java/util/Map.html#ofEntries-java.util.Map.Entry…-).
Jika Anda menggunakan Java 8, Anda dapat memberikan metode Anda sendiri yang mirip dengan ini.
JavaScript array direpresentasikan sebagai `List