```
# Mengonfigurasi Amazon ECS Service Connect dengan AWS CLI
Anda dapat membuat layanan Amazon ECS untuk tugas Fargate yang menggunakan Service Connect dengan. AWS CLI
**catatan**
Anda dapat menggunakan titik akhir layanan dual-stack untuk berinteraksi dengan Amazon ECS dari AWS CLI, SDKs dan Amazon ECS API melalui keduanya dan. IPv4 IPv6 Untuk informasi selengkapnya, lihat [Menggunakan titik akhir tumpukan ganda Amazon ECS](dual-stack-endpoint.md).
## Prasyarat
Berikut ini adalah prasyarat Service Connect:
+ Verifikasi bahwa versi terbaru diinstal dan dikonfigurasi. AWS CLI Untuk informasi selengkapnya, lihat [Menginstal atau memperbarui ke versi terbaru AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ Pengguna IAM Anda memiliki izin yang diperlukan yang ditentukan dalam contoh kebijakan [Amazonecs\$1 FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess) IAM.
+ Anda memiliki VPC, subnet, tabel rute, dan grup keamanan yang dibuat untuk digunakan. Untuk informasi selengkapnya, lihat [Buat virtual private cloud](get-set-up-for-amazon-ecs.md#create-a-vpc).
+ Anda memiliki peran eksekusi tugas dengan nama `ecsTaskExecutionRole` dan kebijakan `AmazonECSTaskExecutionRolePolicy` terkelola dilampirkan ke peran. Peran ini memungkinkan Fargate untuk menulis log aplikasi NGINX dan log proxy Service Connect ke Amazon Logs. CloudWatch Untuk informasi selengkapnya, lihat [Membuat peran eksekusi tugas](task_execution_IAM_role.md#create-task-execution-role).
## Langkah 1: Buat cluster
Gunakan langkah-langkah berikut untuk membuat cluster dan namespace Amazon ECS Anda.
**Untuk membuat cluster dan namespace Amazon ECS AWS Cloud Map**
1. Buat klaster Amazon ECS bernama `tutorial` untuk digunakan. Parameter `--service-connect-defaults` menetapkan namespace default cluster. Dalam contoh output, AWS Cloud Map namespace nama `service-connect` tidak ada di akun ini dan Wilayah AWS, sehingga namespace dibuat oleh Amazon ECS. Namespace dibuat AWS Cloud Map di akun, dan terlihat dengan semua ruang nama lainnya, jadi gunakan nama yang menunjukkan tujuannya.
```
aws ecs create-cluster --cluster-name tutorial --service-connect-defaults namespace=service-connect
```
Output:
```
{
"cluster": {
"clusterArn": "arn:aws:ecs:us-west-2:123456789012:cluster/tutorial",
"clusterName": "tutorial",
"serviceConnectDefaults": {
"namespace": "arn:aws:servicediscovery:us-west-2:123456789012:namespace/ns-EXAMPLE"
},
"status": "PROVISIONING",
"registeredContainerInstancesCount": 0,
"runningTasksCount": 0,
"pendingTasksCount": 0,
"activeServicesCount": 0,
"statistics": [],
"tags": [],
"settings": [
{
"name": "containerInsights",
"value": "disabled"
}
],
"capacityProviders": [],
"defaultCapacityProviderStrategy": [],
"attachments": [
{
"id": "a1b2c3d4-5678-90ab-cdef-EXAMPLE11111",
"type": "sc",
"status": "ATTACHING",
"details": []
}
],
"attachmentsStatus": "UPDATE_IN_PROGRESS"
}
}
}
```
1. Verifikasi bahwa cluster dibuat:
```
aws ecs describe-clusters --clusters tutorial
```
Output:
```
{
"clusters": [
{
"clusterArn": "arn:aws:ecs:us-west-2:123456789012:cluster/tutorial",
"clusterName": "tutorial",
"serviceConnectDefaults": {
"namespace": "arn:aws:servicediscovery:us-west-2:123456789012:namespace/ns-EXAMPLE"
},
"status": "ACTIVE",
"registeredContainerInstancesCount": 0,
"runningTasksCount": 0,
"pendingTasksCount": 0,
"activeServicesCount": 0,
"statistics": [],
"tags": [],
"settings": [],
"capacityProviders": [],
"defaultCapacityProviderStrategy": []
}
],
"failures": []
}
```
1. (Opsional) Verifikasi bahwa namespace dibuat di. AWS Cloud Map Anda dapat menggunakan Konsol Manajemen AWS atau AWS CLI konfigurasi normal saat ini dibuat AWS Cloud Map.
Misalnya, gunakan AWS CLI:
```
aws servicediscovery get-namespace --id ns-EXAMPLE
```
Output:
```
{
"Namespace": {
"Id": "ns-EXAMPLE",
"Arn": "arn:aws:servicediscovery:us-west-2:123456789012:namespace/ns-EXAMPLE",
"Name": "service-connect",
"Type": "HTTP",
"Properties": {
"DnsProperties": {
"SOA": {}
},
"HttpProperties": {
"HttpName": "service-connect"
}
},
"CreateDate": 1661749852.422,
"CreatorRequestId": "service-connect"
}
}
```
## Langkah 2: Buat layanan untuk server
Fitur Service Connect ditujukan untuk menghubungkan beberapa aplikasi di Amazon ECS. Setidaknya salah satu dari aplikasi tersebut perlu menyediakan layanan web untuk terhubung. Pada langkah ini, Anda membuat:
+ Definisi tugas yang menggunakan image kontainer NGINX resmi yang tidak dimodifikasi dan menyertakan konfigurasi Service Connect.
+ Definisi layanan Amazon ECS yang mengonfigurasi Service Connect untuk menyediakan penemuan layanan dan proxy mesh layanan untuk lalu lintas ke layanan ini. Konfigurasi menggunakan kembali namespace default dari konfigurasi cluster untuk mengurangi jumlah konfigurasi layanan yang Anda buat untuk setiap layanan.
+ Layanan Amazon ECS. Ini menjalankan satu tugas menggunakan definisi tugas, dan menyisipkan wadah tambahan untuk proxy Service Connect. Proxy mendengarkan port dari pemetaan port kontainer dari definisi tugas. Dalam aplikasi klien yang berjalan di Amazon ECS, proxy dalam tugas klien mendengarkan koneksi keluar ke nama port definisi tugas, nama penemuan layanan atau nama alias klien layanan, dan nomor port dari alias klien.
**Untuk membuat layanan web dengan Service Connect**
1. Daftarkan definisi tugas yang kompatibel dengan Fargate dan gunakan mode `awsvpc` jaringan. Ikuti langkah-langkah ini:
1. Buat file yang diberi nama `service-connect-nginx.json` dengan isi definisi tugas berikut.
Definisi tugas ini mengonfigurasi Service Connect dengan menambahkan `name` dan `appProtocol` parameter ke pemetaan port. Nama port membuat port ini lebih dapat diidentifikasi dalam konfigurasi layanan ketika beberapa port digunakan. Nama port juga digunakan secara default sebagai nama yang dapat ditemukan untuk digunakan oleh aplikasi lain di namespace.
Definisi tugas berisi peran IAM tugas karena layanan mengaktifkan ECS Exec.
**penting**
Definisi tugas ini menggunakan a `logConfiguration` untuk mengirim output nginx dari `stdout` dan `stderr` ke Amazon Logs. CloudWatch Peran eksekusi tugas ini tidak memiliki izin tambahan yang diperlukan untuk membuat grup CloudWatch log Log. Buat grup log di CloudWatch Log menggunakan Konsol Manajemen AWS or AWS CLI. Jika Anda tidak ingin mengirim log nginx ke Log, Anda CloudWatch dapat menghapus file. `logConfiguration`
Ganti Akun AWS id dalam peran eksekusi tugas dengan Akun AWS id Anda.
```
{
"family": "service-connect-nginx",
"executionRoleArn": "arn:aws:iam::123456789012:role/ecsTaskExecutionRole",
"taskRoleArn": "arn:aws:iam::123456789012:role/ecsTaskRole",
"networkMode": "awsvpc",
"containerDefinitions": [
{
"name": "webserver",
"image": "public.ecr.aws/docker/library/nginx:latest",
"cpu": 100,
"portMappings": [
{
"name": "nginx",
"containerPort": 80,
"protocol": "tcp",
"appProtocol": "http"
}
],
"essential": true,
"logConfiguration": {
"logDriver": "awslogs",
"options": {
"awslogs-group": "/ecs/service-connect-nginx",
"awslogs-region": "region",
"awslogs-stream-prefix": "nginx"
}
}
}
],
"cpu": "256",
"memory": "512"
}
```
1. Daftarkan definisi tugas menggunakan `service-connect-nginx.json` file:
```
aws ecs register-task-definition --cli-input-json file://service-connect-nginx.json
```
1. Buat layanan:
1. Buat file yang diberi nama `service-connect-nginx-service.json` dengan konten layanan Amazon ECS yang Anda buat. Contoh ini menggunakan definisi tugas yang dibuat pada langkah sebelumnya. `awsvpcConfiguration` diperlukan karena ketentuan tugas contoh menggunakan mode jaringan `awsvpc`.
Saat Anda membuat layanan ECS, tentukan Fargate, dan versi platform `LATEST` yang mendukung Service Connect. Itu `securityGroups` dan `subnets` harus milik VPC yang memiliki persyaratan untuk menggunakan Amazon ECS. Anda dapat memperoleh grup keamanan dan subnet IDs dari Konsol VPC Amazon.
Layanan ini mengkonfigurasi Service Connect dengan menambahkan `serviceConnectConfiguration` parameter. Namespace tidak diperlukan karena cluster memiliki namespace default yang dikonfigurasi. Aplikasi klien yang berjalan di ECS di namespace terhubung ke layanan ini dengan menggunakan `portName` dan port di. `clientAliases` Misalnya, layanan ini dapat dijangkau menggunakan`http://nginx:80/`, karena nginx menyediakan halaman selamat datang di lokasi root. `/` Aplikasi eksternal yang tidak berjalan di Amazon ECS atau tidak berada di namespace yang sama dapat mencapai aplikasi ini melalui proxy Service Connect dengan menggunakan alamat IP tugas dan nomor port dari definisi tugas. Untuk `tls` konfigurasi Anda, tambahkan sertifikat `arn` untuk peran IAM Anda `awsPcaAuthorityArn``kmsKey`, Anda, dan `roleArn` Anda.
Layanan ini menggunakan a `logConfiguration` untuk mengirim layanan menghubungkan output proxy dari `stdout` dan `stderr` ke Amazon CloudWatch Logs. Peran eksekusi tugas ini tidak memiliki izin tambahan yang diperlukan untuk membuat grup CloudWatch log Log. Buat grup log di CloudWatch Log menggunakan Konsol Manajemen AWS or AWS CLI. Kami menyarankan Anda membuat grup log ini dan menyimpan log proxy di CloudWatch Log. Jika Anda tidak ingin mengirim log proxy ke CloudWatch Log, Anda dapat menghapus`logConfiguration`.
```
{
"cluster": "tutorial",
"deploymentConfiguration": {
"maximumPercent": 200,
"minimumHealthyPercent": 0
},
"deploymentController": {
"type": "ECS"
},
"desiredCount": 1,
"enableECSManagedTags": true,
"enableExecuteCommand": true,
"launchType": "FARGATE",
"networkConfiguration": {
"awsvpcConfiguration": {
"assignPublicIp": "ENABLED",
"securityGroups": [
"sg-EXAMPLE"
],
"subnets": [
"subnet-EXAMPLE",
"subnet-EXAMPLE",
"subnet-EXAMPLE"
]
}
},
"platformVersion": "LATEST",
"propagateTags": "SERVICE",
"serviceName": "service-connect-nginx-service",
"serviceConnectConfiguration": {
"enabled": true,
"services": [
{
"portName": "nginx",
"clientAliases": [
{
"port": 80
}
],
"tls": {
"issuerCertificateAuthority": {
"awsPcaAuthorityArn": "certificateArn"
},
"kmsKey": "kmsKey",
"roleArn": "iamRoleArn"
}
}
],
"logConfiguration": {
"logDriver": "awslogs",
"options": {
"awslogs-group": "/ecs/service-connect-proxy",
"awslogs-region": "region",
"awslogs-stream-prefix": "service-connect-proxy"
}
}
},
"taskDefinition": "service-connect-nginx"
}
```
1. Buat layanan menggunakan `service-connect-nginx-service.json` file:
```
aws ecs create-service --cluster tutorial --cli-input-json file://service-connect-nginx-service.json
```
Output:
```
{
"service": {
"serviceArn": "arn:aws:ecs:us-west-2:123456789012:service/tutorial/service-connect-nginx-service",
"serviceName": "service-connect-nginx-service",
"clusterArn": "arn:aws:ecs:us-west-2:123456789012:cluster/tutorial",
"loadBalancers": [],
"serviceRegistries": [],
"status": "ACTIVE",
"desiredCount": 1,
"runningCount": 0,
"pendingCount": 0,
"launchType": "FARGATE",
"platformVersion": "LATEST",
"platformFamily": "Linux",
"taskDefinition": "arn:aws:ecs:us-west-2:123456789012:task-definition/service-connect-nginx:1",
"deploymentConfiguration": {
"deploymentCircuitBreaker": {
"enable": false,
"rollback": false
},
"maximumPercent": 200,
"minimumHealthyPercent": 0
},
"deployments": [
{
"id": "ecs-svc/3763308422771520962",
"status": "PRIMARY",
"taskDefinition": "arn:aws:ecs:us-west-2:123456789012:task-definition/service-connect-nginx:1",
"desiredCount": 1,
"pendingCount": 0,
"runningCount": 0,
"failedTasks": 0,
"createdAt": 1661210032.602,
"updatedAt": 1661210032.602,
"launchType": "FARGATE",
"platformVersion": "1.4.0",
"platformFamily": "Linux",
"networkConfiguration": {
"awsvpcConfiguration": {
"assignPublicIp": "ENABLED",
"securityGroups": [
"sg-EXAMPLE"
],
"subnets": [
"subnet-EXAMPLEf",
"subnet-EXAMPLE",
"subnet-EXAMPLE"
]
}
},
"rolloutState": "IN_PROGRESS",
"rolloutStateReason": "ECS deployment ecs-svc/3763308422771520962 in progress.",
"failedLaunchTaskCount": 0,
"replacedTaskCount": 0,
"serviceConnectConfiguration": {
"enabled": true,
"namespace": "service-connect",
"services": [
{
"portName": "nginx",
"clientAliases": [
{
"port": 80
}
]
}
],
"logConfiguration": {
"logDriver": "awslogs",
"options": {
"awslogs-group": "/ecs/service-connect-proxy",
"awslogs-region": "us-west-2",
"awslogs-stream-prefix": "service-connect-proxy"
},
"secretOptions": []
}
},
"serviceConnectResources": [
{
"discoveryName": "nginx",
"discoveryArn": "arn:aws:servicediscovery:us-west-2:123456789012:service/srv-EXAMPLE"
}
]
}
],
"roleArn": "arn:aws:iam::123456789012:role/aws-service-role/ecs.amazonaws.com/AWSServiceRoleForECS",
"version": 0,
"events": [],
"createdAt": 1661210032.602,
"placementConstraints": [],
"placementStrategy": [],
"networkConfiguration": {
"awsvpcConfiguration": {
"assignPublicIp": "ENABLED",
"securityGroups": [
"sg-EXAMPLE"
],
"subnets": [
"subnet-EXAMPLE",
"subnet-EXAMPLE",
"subnet-EXAMPLE"
]
}
},
"schedulingStrategy": "REPLICA",
"enableECSManagedTags": true,
"propagateTags": "SERVICE",
"enableExecuteCommand": true
}
}
```
`serviceConnectConfiguration`Yang Anda berikan muncul di dalam *penyebaran* pertama output. Saat Anda membuat perubahan pada layanan ECS dengan cara yang perlu membuat perubahan pada tugas, penerapan baru dibuat oleh Amazon ECS.
## Langkah 3: Verifikasi bahwa Anda dapat terhubung
Untuk memverifikasi bahwa Service Connect dikonfigurasi dan berfungsi, ikuti langkah-langkah berikut untuk menyambung ke layanan web dari aplikasi eksternal. Kemudian, lihat metrik tambahan dalam CloudWatch proxy Service Connect yang dibuat.
**Untuk terhubung ke layanan web dari aplikasi eksternal**
+ Connect ke alamat IP tugas dan port kontainer menggunakan alamat IP tugas
Gunakan AWS CLI untuk mendapatkan ID tugas, menggunakan file`aws ecs list-tasks --cluster tutorial`.
Jika subnet dan grup keamanan Anda mengizinkan lalu lintas dari internet publik di port dari definisi tugas, Anda dapat terhubung ke IP publik dari komputer Anda. IP publik tidak tersedia dari `describe-tasks`, jadi langkah-langkahnya melibatkan pergi ke Amazon EC2 Konsol Manajemen AWS atau AWS CLI untuk mendapatkan detail dari elastic network interface.
Dalam contoh ini, instans Amazon EC2 di VPC yang sama menggunakan IP pribadi tugas tersebut. Aplikasi ini nginx, tetapi `server: envoy` header menunjukkan bahwa proxy Service Connect digunakan. Proxy Service Connect mendengarkan pada port kontainer dari definisi tugas.
```
$ curl -v 10.0.19.50:80/
* Trying 10.0.19.50:80...
* Connected to 10.0.19.50 (10.0.19.50) port 80 (#0)
> GET / HTTP/1.1
> Host: 10.0.19.50
> User-Agent: curl/7.79.1
> Accept: */*
>
* Mark bundle as not supporting multiuse
< HTTP/1.1 200 OK
< server: envoy
< date: Tue, 23 Aug 2022 03:53:06 GMT
< content-type: text/html
< content-length: 612
< last-modified: Tue, 16 Apr 2019 13:08:19 GMT
< etag: "5cb5d3c3-264"
< accept-ranges: bytes
< x-envoy-upstream-service-time: 0
<
Welcome to nginx!
Welcome to nginx!
If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.
For online documentation and support please refer to
nginx.org.
Commercial support is available at
nginx.com.
Thank you for using nginx.
```
**Untuk melihat metrik Service Connect**
Proxy Service Connect membuat metrik aplikasi (HTTP, HTTP2, gRPC, atau koneksi TCP) dalam metrik. CloudWatch Saat Anda menggunakan CloudWatch konsol, lihat dimensi metrik tambahan **DiscoveryName**, (DiscoveryName,, ClusterName) ** ServiceName,** dan (**TargetDiscoveryName**, **TargetDiscoveryName ServiceName, ClusterName**) di bawah namespace Amazon ECS. Untuk informasi selengkapnya tentang metrik dan dimensi ini, lihat [Melihat Metrik yang Tersedia](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/viewing_metrics_with_cloudwatch.html) di Panduan Pengguna CloudWatch Log Amazon.
# Gunakan penemuan layanan untuk menghubungkan layanan Amazon ECS dengan nama DNS
Layanan Amazon ECS Anda secara opsional dapat dikonfigurasi untuk menggunakan penemuan layanan Amazon ECS. Penemuan layanan menggunakan tindakan AWS Cloud Map API untuk mengelola ruang nama HTTP dan DNS untuk layanan Amazon ECS Anda. Untuk informasi selengkapnya, lihat [Apa yang AWS Cloud Map](https://docs.aws.amazon.com/cloud-map/latest/dg/Welcome.html) Ada di *Panduan AWS Cloud Map Pengembang*.
Penemuan layanan tersedia di AWS Wilayah berikut:
| Nama Wilayah | Region |
| --- | --- |
| AS Timur (Virginia Utara) | us-east-1 |
| US East (Ohio) | us-east-2 |
| AS Barat (California Utara) | us-west-1 |
| US West (Oregon) | as-barat-2 |
| Afrika (Cape Town) | af-selatan-1 |
| Asia Pasifik (Hong Kong) | ap-east-1 |
| Asia Pasifik (Taipei) | ap-timur-2 |
| Asia Pasifik (Mumbai) | ap-south-1 |
| Asia Pasifik (Hyderabad) | ap-south-2 |
| Asia Pasifik (Tokyo) | ap-northeast-1 |
| Asia Pasifik (Seoul) | ap-northeast-2 |
| Asia Pacific (Osaka) | ap-northeast-3 |
| Asia Pasifik (Singapura) | ap-southeast-1 |
| Asia Pacific (Sydney) | ap-southeast-2 |
| Asia Pasifik (Jakarta) | ap-southeast-3 |
| Asia Pacific (Melbourne) | ap-southeast-4 |
| Asia Pasifik (Malaysia) | ap-southeast-5 |
| Asia Pasifik (Selandia Baru) | ap-tenggara 6 |
| Asia Pasifik (Thailand) | ap-tenggara 7 |
| Kanada (Pusat) | ca-central-1 |
| Kanada Barat (Calgary) | ca-west-1 |
| Tiongkok (Beijing) | cn-north-1 |
| China (Ningxia) | cn-northwest-1 |
| Europe (Frankfurt) | eu-central-1 |
| Europe (Zurich) | eu-central-2 |
| Eropa (Irlandia) | eu-west-1 |
| Europe (London) | eu-west-2 |
| Europe (Paris) | eu-west-3 |
| Europe (Milan) | eu-south-1 |
| Eropa (Stockholm) | eu-north-1 |
| Israel (Tel Aviv) | il-central-1 |
| Eropa (Spanyol) | eu-south-2 |
| Timur Tengah (UAE) | me-central-1 |
| Meksiko (Tengah) | mx-pusat-1 |
| Timur Tengah (Bahrain) | me-selatan-1 |
| Amerika Selatan (São Paulo) | sa-east-1 |
| AWS GovCloud (AS-Timur) | us-gov-east-1 |
| AWS GovCloud (AS-Barat) | us-gov-west-1 |
## Konsep Penemuan Layanan
Penemuan layanan terdiri dari komponen-komponen berikut:
+ **Ruang nama penemuan layanan**: Grup logis layanan penemuan layanan yang berbagi nama domain yang sama, seperti`example.com`, tempat Anda ingin merutekan lalu lintas. Anda dapat membuat namespace dengan panggilan ke `aws servicediscovery create-private-dns-namespace` perintah atau di konsol Amazon ECS. Anda dapat menggunakan `aws servicediscovery list-namespaces` perintah untuk melihat informasi ringkasan tentang ruang nama yang dibuat oleh akun saat ini. Untuk informasi selengkapnya tentang perintah penemuan layanan, lihat `[create-private-dns-namespace](https://docs.aws.amazon.com/cli/latest/reference/servicediscovery/create-private-dns-namespace.html)` dan `[list-namespaces](https://docs.aws.amazon.com/cli/latest/reference/servicediscovery/list-namespaces.html)` di *Panduan AWS CLI Referensi AWS Cloud Map (penemuan layanan)*.
+ **Layanan penemuan layanan**: Ada dalam namespace penemuan layanan dan terdiri dari nama layanan dan konfigurasi DNS untuk namespace. Layanan tersebut menyediakan komponen inti berikut:
+ **Registri layanan**: Memungkinkan Anda mencari layanan melalui tindakan DNS atau AWS Cloud Map API dan mendapatkan kembali satu atau lebih titik akhir yang tersedia yang dapat digunakan untuk terhubung ke layanan.
+ **Contoh penemuan layanan**: Ada dalam layanan penemuan layanan dan terdiri dari atribut yang terkait dengan setiap layanan Amazon ECS di direktori layanan.
+ **Atribut instans**: Metadata berikut ditambahkan sebagai atribut khusus untuk setiap layanan Amazon ECS yang dikonfigurasi untuk menggunakan penemuan layanan:
+ **`AWS_INSTANCE_IPV4`**— Sebagai `A` catatan, IPv4 alamat yang dikembalikan Route 53 sebagai respons terhadap kueri DNS dan ditampilkan AWS Cloud Map saat menemukan detail instance, misalnya,. `192.0.2.44`
+ **`AWS_INSTANCE_IPV6`**— Sebagai `AAAA` catatan, IPv6 alamat yang dikembalikan Route 53 sebagai respons terhadap kueri DNS dan ditampilkan AWS Cloud Map saat menemukan detail instance, misalnya,. ` 2001:0db8:85a3:0000:0000:abcd:0001:2345` Keduanya `AWS_INSTANCE_IPv4` dan `AWS_INSTANCE_IPv6` ditambahkan untuk layanan dualstack Amazon ECS. Hanya `AWS_INSTANCE_IPv6` ditambahkan untuk layanan khusus Amazon IPv6 ECS.
+ **`AWS_INSTANCE_PORT`**— Nilai port yang terkait dengan layanan penemuan layanan.
+ **`AVAILABILITY_ZONE`**— Zona Ketersediaan tempat tugas diluncurkan. Untuk tugas yang menggunakan EC2, ini adalah Availability Zone di mana instance container ada. Untuk tugas yang menggunakan Fargate, ini adalah Availability Zone di mana elastic network interface ada.
+ **`REGION`**— Wilayah di mana tugas itu ada.
+ **`ECS_SERVICE_NAME`**— Nama layanan Amazon ECS tempat tugas tersebut berada.
+ **`ECS_CLUSTER_NAME`**— Nama cluster Amazon ECS tempat tugas tersebut berada.
+ **`EC2_INSTANCE_ID`**— ID dari instance kontainer tempat tugas ditempatkan. Atribut kustom ini tidak ditambahkan jika tugas menggunakan Fargate.
+ **`ECS_TASK_DEFINITION_FAMILY`**— Keluarga definisi tugas yang digunakan tugas.
+ **`ECS_TASK_SET_EXTERNAL_ID`**— Jika set tugas dibuat untuk penyebaran eksternal dan dikaitkan dengan registri penemuan layanan, maka `ECS_TASK_SET_EXTERNAL_ID` atribut akan berisi ID eksternal dari set tugas.
+ **Pemeriksaan kesehatan Amazon ECS: Amazon ECS melakukan pemeriksaan kesehatan** tingkat kontainer berkala. Jika titik akhir tidak lulus pemeriksaan kondisi, maka titik akhir akan dihapus dari perutean DNS dan ditandai dengan kondisi tidak baik.
## Pertimbangan penemuan layanan
Berikut ini harus dipertimbangkan saat menggunakan penemuan layanan:
+ Penemuan layanan didukung untuk tugas di Fargate yang menggunakan platform versi 1.1.0 atau yang lebih baru. Untuk informasi selengkapnya, lihat [Versi platform Fargate untuk Amazon ECS](platform-fargate.md).
+ Layanan yang dikonfigurasi untuk menggunakan penemuan layanan memiliki batas 1.000 tugas per layanan. Hal ini dikarenakan kuota layanan Route 53.
+ Alur kerja Create Service di konsol Amazon ECS hanya mendukung pendaftaran layanan ke ruang nama DNS pribadi. Ketika namespace DNS AWS Cloud Map pribadi dibuat, zona host pribadi Route 53 akan dibuat secara otomatis.
+ Atribut DNS VPC harus dikonfigurasi agar resolusi DNS berhasil. Untuk informasi tentang cara mengonfigurasi atribut, lihat [Dukungan DNS di VPC Anda di](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-support) Panduan Pengguna *Amazon VPC*.
+ Amazon ECS tidak mendukung pendaftaran layanan ke ruang AWS Cloud Map nama bersama.
+ Catatan DNS yang dibuat untuk layanan penemuan layanan selalu mendaftar dengan alamat IP pribadi untuk tugas tersebut, bukan alamat IP publik, bahkan ketika ruang nama publik digunakan.
+ Penemuan layanan mengharuskan tugas menentukan mode `awsvpc``bridge`,, atau `host` jaringan (`none`tidak didukung).
+ Jika definisi tugas layanan menggunakan mode `awsvpc` jaringan, Anda dapat membuat kombinasi `A` atau `SRV` catatan apa pun untuk setiap tugas layanan. Jika Anda menggunakan `SRV` catatan, port diperlukan. Anda juga dapat membuat `AAAA` catatan jika layanan menggunakan subnet dualstack. Jika layanan menggunakan subnet IPv6 -only, Anda tidak dapat membuat `A` catatan.
+ Jika definisi tugas layanan menggunakan mode `host` jaringan `bridge` atau, catatan SRV adalah satu-satunya jenis catatan DNS yang didukung. Buat catatan SRV untuk setiap tugas layanan. Catatan SRV harus menentukan kombinasi nama kontainer dan port kontainer dari penentuan tugas.
+ Catatan DNS untuk layanan penemuan layanan dapat ditanyakan dalam VPC Anda. Mereka menggunakan format berikut: `.`.
+ Saat melakukan kueri DNS pada nama layanan, `A` dan `AAAA` catatan mengembalikan satu set alamat IP yang sesuai dengan tugas Anda. `SRV`catatan mengembalikan satu set alamat IP dan port untuk setiap tugas.
+ Jika Anda memiliki delapan atau kurang catatan sehat, Route 53 merespons semua kueri DNS dengan semua catatan sehat.
+ Saat semua catatan tidak sehat, Route 53 akan merespons kueri DNS dengan hingga delapan catatan yang tidak sehat.
+ Anda dapat mengonfigurasi penemuan layanan untuk layanan yang berada di belakang penyeimbang beban, tetapi lalu lintas penemuan layanan selalu diarahkan ke tugas dan bukan penyeimbang beban.
+ Penemuan layanan tidak mendukung penggunaan Classic Load Balancer.
+ Kami menyarankan Anda menggunakan pemeriksaan kesehatan tingkat kontainer yang dikelola oleh Amazon ECS untuk layanan penemuan layanan Anda.
+ **HealthCheckCustomConfig**Amazon ECS mengelola pemeriksaan kesehatan atas nama Anda. Amazon ECS menggunakan informasi dari wadah dan pemeriksaan kesehatan, dan status tugas Anda, untuk memperbarui kesehatan. AWS Cloud Map Ini ditentukan menggunakan `--health-check-custom-config` parameter saat membuat layanan penemuan layanan Anda. Untuk informasi selengkapnya, lihat [HealthCheckCustomConfig](https://docs.aws.amazon.com/cloud-map/latest/api/API_HealthCheckCustomConfig.html) di dalam *Referensi API AWS Cloud Map *.
+ Sumber AWS Cloud Map daya yang dibuat saat penemuan layanan digunakan harus dibersihkan secara manual.
+ Tugas dan instance didaftarkan `UNHEALTHY` sampai pemeriksaan kesehatan kontainer mengembalikan nilai. Jika pemeriksaan kesehatan lulus, status diperbarui ke`HEALTHY`. Jika pemeriksaan kesehatan kontainer gagal, instance penemuan layanan dideregistrasi.
## Harga penemuan layanan
Pelanggan yang menggunakan penemuan layanan Amazon ECS dikenakan biaya untuk sumber daya Route 53 dan operasi API AWS Cloud Map penemuan. Ini melibatkan biaya untuk membuat zona yang dihosting Route 53 dan kueri ke registri layanan. Untuk informasi selengkapnya, lihat [AWS Cloud Map Harga](https://docs.aws.amazon.com/cloud-map/latest/dg/cloud-map-pricing.html) di *Panduan AWS Cloud Map Pengembang*.
Amazon ECS melakukan pemeriksaan kesehatan tingkat kontainer dan memaparkannya ke operasi API pemeriksaan kesehatan AWS Cloud Map khusus. Layanan tersebut saat ini tersedia untuk pelanggan tanpa biaya tambahan. Jika Anda mengonfigurasi pemeriksaan kesehatan jaringan tambahan untuk tugas yang terpapar publik, Anda dikenakan biaya untuk pemeriksaan kesehatan tersebut.
# Membuat layanan Amazon ECS yang menggunakan Service Discovery
Pelajari cara membuat layanan yang berisi tugas Fargate yang menggunakan penemuan layanan dengan. AWS CLI
Untuk daftar penemuan layanan dukungan Wilayah AWS tersebut, lihat[Gunakan penemuan layanan untuk menghubungkan layanan Amazon ECS dengan nama DNS](service-discovery.md).
Untuk informasi tentang Daerah yang mendukung Fargate, lihat. [Wilayah yang Didukung untuk Amazon ECS di Fargate AWS](AWS_Fargate-Regions.md)
**catatan**
Anda dapat menggunakan titik akhir layanan dual-stack untuk berinteraksi dengan Amazon ECS dari AWS CLI, SDKs dan Amazon ECS API melalui keduanya dan. IPv4 IPv6 Untuk informasi selengkapnya, lihat [Menggunakan titik akhir tumpukan ganda Amazon ECS](dual-stack-endpoint.md).
## Prasyarat
Sebelum Anda memulai tutorial ini, pastikan bahwa prasyarat berikut terpenuhi:
+ Versi terbaru diinstal dan dikonfigurasi. AWS CLI Untuk informasi selengkapnya, lihat [Menginstal atau memperbarui ke versi terbaru AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ Langkah-langkah yang dijelaskan di dalamnya [Siapkan untuk menggunakan Amazon ECS](get-set-up-for-amazon-ecs.md) sudah lengkap.
+ Pengguna IAM Anda memiliki izin yang diperlukan yang ditentukan dalam contoh kebijakan [Amazonecs\$1 FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess) IAM.
+ Anda telah membuat setidaknya satu VPC dan satu grup keamanan. Untuk informasi selengkapnya, lihat [Buat virtual private cloud](get-set-up-for-amazon-ecs.md#create-a-vpc).
## Langkah 1: Buat sumber daya Penemuan Layanan di AWS Cloud Map
Ikuti langkah-langkah berikut untuk membuat namespace penemuan layanan dan layanan penemuan layanan Anda:
1. Buat namespace penemuan layanan Cloud Map pribadi. Contoh ini menciptakan namespace yang disebut. `tutorial` Ganti *vpc-abcd1234* dengan ID salah satu yang sudah ada VPCs.
```
aws servicediscovery create-private-dns-namespace \
--name tutorial \
--vpc vpc-abcd1234
```
Output dari perintah ini adalah sebagai berikut.
```
{
"OperationId": "h2qe3s6dxftvvt7riu6lfy2f6c3jlhf4-je6chs2e"
}
```
1. Menggunakan `OperationId` dari output dari langkah sebelumnya, verifikasi bahwa namespace pribadi berhasil dibuat. Catat ID namespace karena Anda menggunakannya dalam perintah berikutnya.
```
aws servicediscovery get-operation \
--operation-id h2qe3s6dxftvvt7riu6lfy2f6c3jlhf4-je6chs2e
```
Outputnya adalah sebagai berikut.
```
{
"Operation": {
"Id": "h2qe3s6dxftvvt7riu6lfy2f6c3jlhf4-je6chs2e",
"Type": "CREATE_NAMESPACE",
"Status": "SUCCESS",
"CreateDate": 1519777852.502,
"UpdateDate": 1519777856.086,
"Targets": {
"NAMESPACE": "ns-uejictsjen2i4eeg"
}
}
}
```
1. Menggunakan `NAMESPACE` ID dari output dari langkah sebelumnya, buat layanan penemuan layanan. Contoh ini menciptakan layanan bernama`myapplication`. Catat ID layanan dan ARN karena Anda menggunakannya dalam perintah berikutnya.
```
aws servicediscovery create-service \
--name myapplication \
--dns-config "NamespaceId="ns-uejictsjen2i4eeg",DnsRecords=[{Type="A",TTL="300"}]" \
--health-check-custom-config FailureThreshold=1
```
Outputnya adalah sebagai berikut.
```
{
"Service": {
"Id": "srv-utcrh6wavdkggqtk",
"Arn": "arn:aws:servicediscovery:region:aws_account_id:service/srv-utcrh6wavdkggqtk",
"Name": "myapplication",
"DnsConfig": {
"NamespaceId": "ns-uejictsjen2i4eeg",
"DnsRecords": [
{
"Type": "A",
"TTL": 300
}
]
},
"HealthCheckCustomConfig": {
"FailureThreshold": 1
},
"CreatorRequestId": "e49a8797-b735-481b-a657-b74d1d6734eb"
}
}
```
## Langkah 2: Buat sumber daya Amazon ECS
Ikuti langkah-langkah berikut untuk membuat klaster Amazon ECS, definisi tugas, dan layanan:
1. Buat cluster Amazon ECS. Contoh ini menciptakan sebuah cluster yang diberi nama`tutorial`.
```
aws ecs create-cluster \
--cluster-name tutorial
```
1. Daftarkan definisi tugas yang kompatibel dengan Fargate dan gunakan mode `awsvpc` jaringan. Ikuti langkah-langkah ini:
1. Buat file yang diberi nama `fargate-task.json` dengan isi definisi tugas berikut.
```
{
"family": "tutorial-task-def",
"networkMode": "awsvpc",
"containerDefinitions": [
{
"name": "sample-app",
"image": "public.ecr.aws/docker/library/httpd:2.4",
"portMappings": [
{
"containerPort": 80,
"hostPort": 80,
"protocol": "tcp"
}
],
"essential": true,
"entryPoint": [
"sh",
"-c"
],
"command": [
"/bin/sh -c \"echo ' Amazon ECS Sample App Amazon ECS Sample App
Congratulations!
Your application is now running on a container in Amazon ECS.
' > /usr/local/apache2/htdocs/index.html && httpd-foreground\""
]
}
],
"requiresCompatibilities": [
"FARGATE"
],
"cpu": "256",
"memory": "512"
}
```
1. Daftarkan definisi tugas menggunakan`fargate-task.json`.
```
aws ecs register-task-definition \
--cli-input-json file://fargate-task.json
```
1. Buat layanan ECS dengan mengikuti langkah-langkah berikut:
1. Buat file yang diberi nama `ecs-service-discovery.json` dengan konten layanan ECS yang Anda buat. Contoh ini menggunakan definisi tugas yang dibuat pada langkah sebelumnya. `awsvpcConfiguration` diperlukan karena ketentuan tugas contoh menggunakan mode jaringan `awsvpc`.
Saat Anda membuat layanan ECS, tentukan Fargate dan versi platform `LATEST` yang mendukung penemuan layanan. Ketika layanan penemuan layanan dibuat di AWS Cloud Map , `registryArn` adalah ARN dikembalikan. Itu `securityGroups` dan `subnets` harus milik VPC yang digunakan untuk membuat namespace Cloud Map. Anda dapat memperoleh grup keamanan dan subnet IDs dari Konsol VPC Amazon.
```
{
"cluster": "tutorial",
"serviceName": "ecs-service-discovery",
"taskDefinition": "tutorial-task-def",
"serviceRegistries": [
{
"registryArn": "arn:aws:servicediscovery:region:aws_account_id:service/srv-utcrh6wavdkggqtk"
}
],
"launchType": "FARGATE",
"platformVersion": "LATEST",
"networkConfiguration": {
"awsvpcConfiguration": {
"assignPublicIp": "ENABLED",
"securityGroups": [ "sg-abcd1234" ],
"subnets": [ "subnet-abcd1234" ]
}
},
"desiredCount": 1
}
```
1. Buat layanan ECS Anda menggunakan`ecs-service-discovery.json`.
```
aws ecs create-service \
--cli-input-json file://ecs-service-discovery.json
```
## Langkah 3: Verifikasi Penemuan Layanan di AWS Cloud Map
Anda dapat memverifikasi bahwa semuanya dibuat dengan benar dengan menanyakan informasi penemuan layanan Anda. Setelah penemuan layanan dikonfigurasi, Anda dapat menggunakan operasi AWS Cloud Map API, atau menelepon `dig` dari instance dalam VPC Anda. Ikuti langkah-langkah ini:
1. Dengan menggunakan ID layanan penemuan layanan, cantumkan instance penemuan layanan. Catat ID instance (ditandai dengan huruf tebal) untuk pembersihan sumber daya.
```
aws servicediscovery list-instances \
--service-id srv-utcrh6wavdkggqtk
```
Outputnya adalah sebagai berikut.
```
{
"Instances": [
{
"Id": "16becc26-8558-4af1-9fbd-f81be062a266",
"Attributes": {
"AWS_INSTANCE_IPV4": "172.31.87.2"
"AWS_INSTANCE_PORT": "80",
"AVAILABILITY_ZONE": "us-east-1a",
"REGION": "us-east-1",
"ECS_SERVICE_NAME": "ecs-service-discovery",
"ECS_CLUSTER_NAME": "tutorial",
"ECS_TASK_DEFINITION_FAMILY": "tutorial-task-def"
}
}
]
}
```
1. Gunakan namespace penemuan layanan, layanan, dan parameter tambahan seperti nama cluster ECS untuk menanyakan detail tentang instance penemuan layanan.
```
aws servicediscovery discover-instances \
--namespace-name tutorial \
--service-name myapplication \
--query-parameters ECS_CLUSTER_NAME=tutorial
```
1. Catatan DNS yang dibuat di zona host Route 53 untuk layanan penemuan layanan dapat ditanyakan dengan perintah berikut: AWS CLI
1. Menggunakan ID namespace, dapatkan informasi tentang namespace, yang mencakup ID zona yang dihosting Route 53.
```
aws servicediscovery \
get-namespace --id ns-uejictsjen2i4eeg
```
Outputnya adalah sebagai berikut.
```
{
"Namespace": {
"Id": "ns-uejictsjen2i4eeg",
"Arn": "arn:aws:servicediscovery:region:aws_account_id:namespace/ns-uejictsjen2i4eeg",
"Name": "tutorial",
"Type": "DNS_PRIVATE",
"Properties": {
"DnsProperties": {
"HostedZoneId": "Z35JQ4ZFDRYPLV"
}
},
"CreateDate": 1519777852.502,
"CreatorRequestId": "9049a1d5-25e4-4115-8625-96dbda9a6093"
}
}
```
1. Menggunakan ID zona yang dihosting Route 53 dari langkah sebelumnya (lihat teks dalam huruf tebal), dapatkan catatan sumber daya yang ditetapkan untuk zona yang dihosting.
```
aws route53 list-resource-record-sets \
--hosted-zone-id Z35JQ4ZFDRYPLV
```
1. Anda juga dapat menanyakan DNS dari instance dalam `dig` VPC Anda menggunakan.
```
dig +short myapplication.tutorial
```
## Langkah 4: Membersihkan
Setelah selesai dengan tutorial ini, bersihkan sumber daya terkait untuk menghindari biaya untuk sumber daya yang tidak digunakan. Ikuti langkah-langkah ini:
1. Batalkan pendaftaran instance layanan penemuan layanan menggunakan ID layanan dan ID instans yang Anda catat sebelumnya.
```
aws servicediscovery deregister-instance \
--service-id srv-utcrh6wavdkggqtk \
--instance-id 16becc26-8558-4af1-9fbd-f81be062a266
```
Outputnya adalah sebagai berikut.
```
{
"OperationId": "xhu73bsertlyffhm3faqi7kumsmx274n-jh0zimzv"
}
```
1. Menggunakan `OperationId` dari output dari langkah sebelumnya, verifikasi bahwa instance layanan penemuan layanan berhasil dideregistrasi.
```
aws servicediscovery get-operation \
--operation-id xhu73bsertlyffhm3faqi7kumsmx274n-jh0zimzv
```
```
{
"Operation": {
"Id": "xhu73bsertlyffhm3faqi7kumsmx274n-jh0zimzv",
"Type": "DEREGISTER_INSTANCE",
"Status": "SUCCESS",
"CreateDate": 1525984073.707,
"UpdateDate": 1525984076.426,
"Targets": {
"INSTANCE": "16becc26-8558-4af1-9fbd-f81be062a266",
"ROUTE_53_CHANGE_ID": "C5NSRG1J4I1FH",
"SERVICE": "srv-utcrh6wavdkggqtk"
}
}
}
```
1. Hapus layanan penemuan layanan menggunakan ID layanan.
```
aws servicediscovery delete-service \
--id srv-utcrh6wavdkggqtk
```
1. Hapus namespace penemuan layanan menggunakan ID namespace.
```
aws servicediscovery delete-namespace \
--id ns-uejictsjen2i4eeg
```
Outputnya adalah sebagai berikut.
```
{
"OperationId": "c3ncqglftesw4ibgj5baz6ktaoh6cg4t-jh0ztysj"
}
```
1. Menggunakan `OperationId` dari output dari langkah sebelumnya, verifikasi bahwa namespace penemuan layanan berhasil dihapus.
```
aws servicediscovery get-operation \
--operation-id c3ncqglftesw4ibgj5baz6ktaoh6cg4t-jh0ztysj
```
Outputnya adalah sebagai berikut.
```
{
"Operation": {
"Id": "c3ncqglftesw4ibgj5baz6ktaoh6cg4t-jh0ztysj",
"Type": "DELETE_NAMESPACE",
"Status": "SUCCESS",
"CreateDate": 1525984602.211,
"UpdateDate": 1525984602.558,
"Targets": {
"NAMESPACE": "ns-rymlehshst7hhukh",
"ROUTE_53_CHANGE_ID": "CJP2A2M86XW3O"
}
}
}
```
1. Perbarui hitungan yang diinginkan untuk layanan Amazon ECS ke`0`. Anda harus melakukan ini untuk menghapus layanan di langkah berikutnya.
```
aws ecs update-service \
--cluster tutorial \
--service ecs-service-discovery \
--desired-count 0
```
1. Hapus layanan Amazon ECS.
```
aws ecs delete-service \
--cluster tutorial \
--service ecs-service-discovery
```
1. Hapus cluster Amazon ECS.
```
aws ecs delete-cluster \
--cluster tutorial
```
# Gunakan Amazon VPC Lattice untuk menghubungkan, mengamati, dan mengamankan layanan Amazon ECS Anda
Amazon VPC Lattice adalah layanan jaringan aplikasi yang dikelola sepenuhnya yang memungkinkan pelanggan Amazon ECS untuk mengamati, mengamankan, dan memantau aplikasi yang dibangun di seluruh layanan AWS komputasi, VPCs, dan akun — tanpa memerlukan perubahan kode apa pun.
VPC Lattice menggunakan kelompok target, yang merupakan kumpulan sumber daya komputasi. Target ini menjalankan aplikasi atau layanan Anda dan dapat berupa instans Amazon EC2, alamat IP, fungsi Lambda, dan Application Load Balancer. Dengan mengaitkan layanan Amazon ECS mereka dengan grup target VPC Lattice, pelanggan sekarang dapat mengaktifkan tugas Amazon ECS sebagai target IP di VPC Lattice. Amazon ECS secara otomatis mendaftarkan tugas ke grup target VPC Lattice saat tugas untuk layanan terdaftar diluncurkan.
**catatan**
Saat menggunakan lima konfigurasi VPC Lattice, waktu penerapan Anda mungkin sedikit lebih lama daripada saat menggunakan konfigurasi yang lebih sedikit.
Aturan pendengar digunakan untuk meneruskan lalu lintas ke grup target tertentu saat kondisi terpenuhi. Pendengar memeriksa permintaan koneksi menggunakan protokol pada port yang Anda konfigurasikan. Layanan merutekan permintaan ke target terdaftar berdasarkan aturan yang Anda tentukan saat mengonfigurasi listener Anda.
Amazon ECS juga secara otomatis menggantikan tugas jika menjadi tidak sehat menurut pemeriksaan kesehatan VPC Lattice. Setelah dikaitkan dengan VPC Lattice, pelanggan Amazon ECS juga dapat memanfaatkan banyak fitur konektivitas, keamanan, dan observabilitas lintas komputasi lainnya di VPC Lattice seperti menghubungkan ke layanan di seluruh cluster,, dan akun dengan, integrasi IAM untuk otorisasi dan otentikasi VPCs, dan fitur manajemen AWS Resource Access Manager lalu lintas lanjutan.
Pelanggan Amazon ECS dapat memanfaatkan VPC Lattice dengan cara berikut.
+ Peningkatan produktivitas pengembang - VPC Lattice meningkatkan produktivitas pengembang dengan membiarkan Anda fokus pada membangun fitur, sementara VPC Lattice menangani tantangan jaringan, keamanan, dan pengamatan secara seragam di semua platform komputasi.
+ Postur keamanan yang lebih baik - VPC Lattice memungkinkan pengembang Anda untuk dengan mudah mengautentikasi dan mengamankan komunikasi di seluruh aplikasi dan platform komputasi, menegakkan enkripsi dalam perjalanan, dan menerapkan kontrol akses granular dengan kebijakan VPC Lattice Auth. Ini memungkinkan Anda untuk mengadopsi postur keamanan yang lebih kuat yang memenuhi persyaratan peraturan dan kepatuhan terkemuka di industri.
+ Peningkatan skalabilitas dan ketahanan aplikasi - VPC Lattice memungkinkan Anda membuat jaringan aplikasi yang digunakan dengan fitur seperti path, header, dan routing berbasis metode, otentikasi, otorisasi, dan pemantauan. Manfaat ini diberikan tanpa overhead sumber daya pada beban kerja dan dapat mendukung penerapan multi-cluster yang menghasilkan jutaan permintaan per detik tanpa menambahkan latensi yang signifikan.
+ Fleksibilitas penerapan dengan infrastruktur heterogen - VPC Lattice menyediakan fitur yang konsisten di semua layanan komputasi seperti Amazon ECS, Fargate, Amazon EC2, Amazon EKS, dan Lambda dan memungkinkan organisasi Anda fleksibilitas untuk memilih infrastruktur yang sesuai untuk setiap aplikasi.
## Bagaimana VPC Lattice bekerja dengan layanan Amazon ECS lainnya
Menggunakan VPC Lattice dengan Amazon ECS dapat mengubah cara Anda menggunakan layanan Amazon ECS lainnya, sementara yang lain tetap sama.
**Application Load Balancer**
Anda tidak perlu lagi membuat Application Load Balancer tertentu untuk digunakan dengan tipe grup target Application Load Balancer di VPC Lattice yang kemudian ditautkan ke layanan Amazon ECS. Anda hanya perlu mengonfigurasi layanan Amazon ECS Anda dengan grup target VPC Lattice sebagai gantinya. Anda juga dapat memilih untuk menggunakan Application Load Balancer dengan Amazon ECS secara bersamaan.
**Penerapan bergulir Amazon ECS**
Hanya penerapan bergulir Amazon ECS yang berfungsi dengan VPC Lattice, dan Amazon ECS dengan aman membawa tugas ke dalam dan menghapusnya dari layanan selama penerapan. Blue/Green Penyebaran dan penerapan kode tidak didukung.
Untuk mempelajari selengkapnya tentang VPC Lattice, lihat Panduan Pengguna Amazon [VPC](https://docs.aws.amazon.com/vpc-lattice/latest/ug/what-is-vpc-lattice.html) Lattice.
# Buat layanan yang menggunakan VPC Lattice
Anda dapat menggunakan salah satu Konsol Manajemen AWS atau AWS CLI untuk membuat layanan dengan VPC Lattice.
## Prasyarat
Sebelum Anda memulai tutorial ini, pastikan bahwa prasyarat berikut terpenuhi:
+ Versi terbaru diinstal dan dikonfigurasi. AWS CLI Untuk informasi selengkapnya, silakan lihat [ Menginstal AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html).
**catatan**
Anda dapat menggunakan titik akhir layanan dual-stack untuk berinteraksi dengan Amazon ECS dari AWS CLI, SDKs dan Amazon ECS API melalui keduanya dan. IPv4 IPv6 Untuk informasi selengkapnya, lihat [Menggunakan titik akhir tumpukan ganda Amazon ECS](dual-stack-endpoint.md).
+ Langkah-langkah yang dijelaskan di dalamnya [Siapkan untuk menggunakan Amazon ECS](get-set-up-for-amazon-ecs.md) sudah lengkap.
+ Pengguna IAM Anda memiliki izin yang diperlukan yang ditentukan dalam contoh kebijakan [Amazonecs\$1 FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess) IAM.
## Buat layanan yang menggunakan VPC Lattice dengan Konsol Manajemen AWS
Ikuti langkah-langkah ini untuk membuat layanan dengan VPC Lattice menggunakan. Konsol Manajemen AWS
1. Buka konsol di [https://console.aws.amazon.com/ecs/v2](https://console.aws.amazon.com/ecs/v2).
1. Di halaman navigasi, pilih **Cluster**.
1. Pada halaman **Clusters**, pilih cluster untuk membuat layanan di.
1. Dari tab **Layanan**, pilih **Buat**.
Jika Anda belum pernah membuat layanan sebelumnya, ikuti langkah-langkah yang ditemukan di [Membuat layanan Amazon ECS menggunakan konsol](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service-console-v2.html), lalu lanjutkan dengan langkah-langkah ini saat Anda mencapai bagian Kisi VPC.
1. Pilih untuk **Menghidupkan Kisi VPC** dengan mencentang tombol.
1. Untuk menggunakan peran yang ada, untuk **peran infrastruktur ECS untuk Amazon ECS**, pilih salah satu yang telah Anda buat untuk digunakan saat membuat grup target VPC Lattice. Untuk membuat peran baru, **Buat peran infrastruktur ECS**.
1. Pilih **VPC**.
**VPC** tergantung pada mode jaringan yang Anda pilih saat Anda mendaftarkan definisi tugas Anda. Jika Anda menggunakan `network` mode `host` or dengan EC2, pilih VPC Anda.
Untuk `awsvpc` mode, VPC dipilih secara otomatis berdasarkan VPC yang Anda pilih di bawah **Jaringan** dan tidak dapat diubah.
1. Di bawah **Grup Target** pilih grup target atau grup. Anda harus memilih setidaknya satu kelompok sasaran dan dapat memiliki maksimal lima. Pilih **Tambahkan grup target** untuk menambahkan grup target tambahan. Pilih **nama Port**, **Protokol**, dan **Port** untuk setiap grup target yang Anda pilih. Untuk menghapus grup target, pilih **Hapus**.
**catatan**
Jika Anda ingin menambahkan grup target yang ada, Anda perlu menggunakan AWS CLI. *Untuk petunjuk tentang cara menambahkan grup target menggunakan AWS CLI, lihat [daftar target di Referensi](https://docs.aws.amazon.com/cli/latest/reference/vpc-lattice/register-targets.html). AWS Command Line Interface *
Meskipun layanan VPC Lattice dapat memiliki beberapa grup target, setiap grup target hanya dapat ditambahkan ke satu layanan.
Untuk membuat layanan dalam konfigurasi IPv6 -only, pilih grup target dengan jenis `IPv6` alamat IP.
1. Pada titik ini, Anda menavigasi ke konsol VPC Lattice untuk melanjutkan pengaturan. Di sinilah Anda menyertakan grup target baru dalam tindakan default listener atau dalam aturan layanan VPC Lattice yang ada.
Untuk informasi selengkapnya, lihat [Aturan pendengar untuk layanan Kisi VPC Anda](https://docs.aws.amazon.com/vpc-lattice/latest/ug/listener-rules.html).
**penting**
Anda harus mengizinkan `vpc-lattice` awalan aturan masuk ke grup keamanan atau tugas Anda dan pemeriksaan kesehatan dapat gagal.
## Buat layanan yang menggunakan VPC Lattice dengan AWS CLI
Gunakan AWS CLI untuk membuat layanan dengan VPC Lattice. Ganti masing-masing *user input placeholder* dengan informasi Anda sendiri.
1. Buat file konfigurasi grup target. Contoh berikut diberi nama `tg-config.json`
```
{
"ipAddressType": "IPV4",
"port": 443,
"protocol": "HTTPS",
"protocolVersion": "HTTP1",
"vpcIdentifier": "vpc-f1663d9868EXAMPLE"
}
```
1. Gunakan perintah berikut untuk membuat grup target VPC Lattice.
```
aws vpc-lattice create-target-group \
--name my-lattice-target-group-ip \
--type IP \
--config file://tg-config.json
```
**catatan**
Untuk membuat layanan dalam konfigurasi IPv6 -only, buat grup target dengan jenis `IPv6` alamat IP. Untuk informasi selengkapnya, lihat [create-target-group](https://docs.aws.amazon.com/cli/latest/reference/vpc-lattice/create-target-group.html) dalam *AWS CLI Referensi Perintah*.
Contoh output:
```
{
"arn": "arn:aws:vpc-lattice:us-east-2:123456789012:targetgroup/tg-0eaa4b9ab4EXAMPLE",
"config": {
"healthCheck": {
"enabled": true,
"healthCheckIntervalSeconds": 30,
"healthCheckTimeoutSeconds": 5,
"healthyThresholdCount": 5,
"matcher": {
"httpCode": "200"
},
"path": "/",
"protocol": "HTTPS",
"protocolVersion": "HTTP1",
"unhealthyThresholdCount": 2
},
"ipAddressType": "IPV4",
"port": 443,
"protocol": "HTTPS",
"protocolVersion": "HTTP1",
"vpcIdentifier": "vpc-f1663d9868EXAMPLE"
},
"id": "tg-0eaa4b9ab4EXAMPLE",
"name": "my-lattice-target-group-ip",
"status": "CREATE_IN_PROGRESS",
"type": "IP"
}
```
1. File JSON berikut bernama *ecs-service-vpc-lattice.json* adalah contoh yang digunakan untuk melampirkan layanan Amazon ECS ke grup target VPC Lattice. Contoh `portName` di bawah ini sama dengan yang Anda tentukan di `name` bidang `portMappings` properti definisi tugas Anda.
```
{
"serviceName": "ecs-service-vpc-lattice",
"taskDefinition": "ecs-task-def",
"vpcLatticeConfigurations": [
{
"targetGroupArn": "arn:aws:vpc-lattice:us-west-2:123456789012:targetgroup/tg-0eaa4b9ab4EXAMPLE",
"portName": "testvpclattice",
"roleArn": "arn:aws:iam::123456789012:role/ecsInfrastructureRoleVpcLattice"
}
],
"desiredCount": 5,
"role": "ecsServiceRole"
}
```
Gunakan perintah berikut untuk membuat layanan Amazon ECS dan melampirkannya ke grup target VPC Lattice menggunakan contoh json di atas.
```
aws ecs create-service \
--cluster clusterName \
--serviceName ecs-service-vpc-lattice \
--cli-input-json file://ecs-service-vpc-lattice.json
```
**catatan**
VPC Lattice tidak didukung di Amazon ECS Anywhere.