```
# Konfiguration von Amazon ECS Service Connect mit dem AWS CLI
Sie können mit der AWS CLI einen Amazon-ECS-Service mit einer Fargate-Aufgabe erstellen, die Service Connect verwendet.
**Anmerkung**
Sie können Dual-Stack-Service-Endpunkte verwenden, um mit Amazon ECS über die AWS CLI SDKs, und die Amazon ECS-API sowohl über als auch IPv4 zu interagieren. IPv6 Weitere Informationen finden Sie unter [Verwenden von Dual-Stack-Endpunkten in Amazon ECS](dual-stack-endpoint.md).
## Voraussetzungen
Im Folgenden sind die Voraussetzungen für Service Connect aufgeführt:
+ Stellen Sie sicher, dass die neueste Version von installiert und konfiguriert AWS CLI ist. Weitere Informationen finden Sie unter [Installieren oder Aktualisierung auf die neueste Version der AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ Ihr IAM-Benutzer besitzt die im [AmazonECS\$1 FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess)-IAM-Richtlinienbeispiel angegebenen Berechtigungen.
+ Sie haben eine VPC, ein Subnetz, eine Routing-Tabelle und eine Sicherheitsgruppe zur Verwendung erstellt. Weitere Informationen finden Sie unter [Erstellen einer Virtual Private Cloud](get-set-up-for-amazon-ecs.md#create-a-vpc).
+ Sie verfügen über eine Aufgabenausführungsrolle mit dem Namen `ecsTaskExecutionRole` und die von `AmazonECSTaskExecutionRolePolicy` verwaltete Richtlinie ist der Rolle angefügt. Diese Rolle ermöglicht es Fargate, die NGINX-Anwendungsprotokolle und Service Connect-Proxyprotokolle in Amazon Logs zu schreiben. CloudWatch Weitere Informationen finden Sie unter [Erstellen der -Aufgabenausführungsrolle](task_execution_IAM_role.md#create-task-execution-role).
## Schritt 1: Cluster erstellen
Führen Sie die folgenden Schritte aus, um Ihren Amazon-ECS-Cluster und -Namespace zu erstellen.
**Um den Amazon ECS-Cluster und den AWS Cloud Map Namespace zu erstellen**
1. Erstellen Sie einen zu verwendenden Amazon-ECS-Cluster mit dem Namen `tutorial`. Der Parameter `--service-connect-defaults` legt den Standard-Namespace des Clusters fest. In der Beispielausgabe ist in diesem Konto `service-connect` kein AWS Cloud Map Namespace mit dem Namen vorhanden AWS-Region, weshalb der Namespace von Amazon ECS erstellt wurde. Der Namespace wird in AWS Cloud Map im Konto erstellt und ist mit allen anderen Namespaces sichtbar. Verwenden Sie daher einen Namen, der den Zweck angibt.
```
aws ecs create-cluster --cluster-name tutorial --service-connect-defaults namespace=service-connect
```
Ausgabe:
```
{
"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. Stellen Sie sicher, dass der Cluster erstellt wurde:
```
aws ecs describe-clusters --clusters tutorial
```
Ausgabe:
```
{
"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. (Optional) Stellen Sie sicher, dass der Namespace in erstellt wurde. AWS Cloud Map Sie können die AWS-Managementkonsole oder die normale AWS CLI Konfiguration verwenden, in AWS Cloud Map der dieser erstellt wurde.
Verwenden Sie beispielsweise die AWS CLI:
```
aws servicediscovery get-namespace --id ns-EXAMPLE
```
Ausgabe:
```
{
"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"
}
}
```
## Schritt 2: Erstellen des Service für den Server
Das Service-Connect-Feature dient zum Verbinden mehrerer Anwendungen auf Amazon ECS. Mindestens eine dieser Anwendungen muss einen Web-Service bereitstellen, zu dem eine Verbindung hergestellt werden kann. In diesem Schritt erstellen Sie:
+ Die Aufgabendefinition, die das unveränderte offizielle Nginx-Container-Image verwendet und die Service-Connect-Konfiguration beinhaltet.
+ Die Amazon-ECS-Servicedefinition, die Service Connect konfiguriert, um Serviceerkennung und Service-Mesh-Proxy für Datenverkehr zu diesem Service bereitzustellen. Die Konfiguration verwendet den Standard-Namespace aus der Cluster-Konfiguration erneut, um den Umfang der Service-Konfiguration, die Sie für jeden Service vornehmen, zu reduzieren.
+ Der Amazon-ECS-Service. Er führt eine Aufgabe mithilfe der Aufgabendefinition aus und fügt einen zusätzlichen Container für den Service-Connect-Proxy ein. Der Proxy überwacht den Port aus der Container-Port-Zuordnung der Aufgabendefinition. In einer Client-Anwendung, die in Amazon ECS ausgeführt wird, wartet der Proxy in der Client-Aufgabe auf ausgehende Verbindungen mit dem Portnamen der Aufgabendefinition, dem Serviceerkennungsnamen oder dem Service-Client-Aliasnamen und der Portnummer des Client-Alias.
**So erstellen Sie den Webservice mit Service Connect**
1. Registrieren Sie eine Aufgabendefinition, die mit Fargate kompatibel ist und den `awsvpc`-Netzwerkmodus verwendet. Dazu gehen Sie wie folgt vor:
1. Erstellen Sie eine Datei mit dem Namen `service-connect-nginx.json` mit dem Inhalt der folgenden Aufgabendefinition.
Diese Aufgabendefinition konfiguriert Service Connect durch Hinzufügen von `name`- und `appProtocol`-Parametern zur Portzuordnung. Durch den Portnamen wird dieser Port in der Service-Konfiguration besser identifizierbar, wenn mehrere Ports verwendet werden. Der Portname wird standardmäßig auch als auffindbarer Name für andere Anwendungen im Namespace verwendet.
Die Aufgabendefinition enthält die Aufgaben-IAM-Rolle, da für den Service ECS Exec aktiviert ist.
**Wichtig**
Diese Aufgabendefinition verwendet a`logConfiguration`, um die Nginx-Ausgabe von `stdout` und an Amazon CloudWatch Logs `stderr` zu senden. Diese Rolle zur Aufgabenausführung verfügt nicht über die zusätzlichen Berechtigungen, die für die Erstellung der Protokollgruppe CloudWatch Logs erforderlich sind. Erstellen Sie die Protokollgruppe in CloudWatch Logs mithilfe von AWS-Managementkonsole oder AWS CLI. Wenn Sie die Nginx-Protokolle nicht an Logs senden möchten, CloudWatch können Sie die entfernen. `logConfiguration`
Ersetzen Sie die AWS-Konto ID in der Rolle zur Aufgabenausführung durch Ihre AWS-Konto ID.
```
{
"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. Registrieren Sie die Aufgabendefinition mit der `service-connect-nginx.json`-Datei:
```
aws ecs register-task-definition --cli-input-json file://service-connect-nginx.json
```
1. Erstellen eines Services:
1. Erstellen Sie eine Datei mit dem Namen `service-connect-nginx-service.json` mit dem Inhalt des Amazon-ECS-Service, den Sie erstellen. Dieses Beispiel verwendet die Aufgabendefinition, die im vorherigen Schritt erstellt wurde. Ein `awsvpcConfiguration` ist erforderlich, da die Beispiel-Aufgabendefinition den `awsvpc`-Netzwerkmodus verwendet.
Wenn Sie den ECS-Service erstellen, geben Sie den Fargate und die `LATEST`-Plattformversion an, die Service Connect unterstützt. Die `securityGroups` und `subnets` müssen zu einer VPC gehören, die die Anforderungen für die Verwendung von Amazon ECS erfüllt. Sie können die Sicherheitsgruppe und das Subnetz IDs von der Amazon VPC-Konsole abrufen.
Dieser Service konfiguriert Service Connect durch Hinzufügen des `serviceConnectConfiguration`-Parameters. Der Namespace ist nicht erforderlich, da für den Cluster ein Standard-Namespace konfiguriert ist. Client-Anwendungen, die in ECS im Namespace ausgeführt werden, stellen eine Verbindung zu diesem Service her, indem sie den `portName` und den Port im `clientAliases` verwenden. Dieser Service ist beispielsweise über `http://nginx:80/` erreichbar, da Nginx eine Willkommensseite im Stammverzeichnis `/` bereitstellt. Externe Anwendungen, die nicht in Amazon ECS ausgeführt werden oder sich nicht im selben Namespace befinden, können diese Anwendung über den Service-Connect-Proxy erreichen, indem sie die IP-Adresse der Aufgabe und die Portnummer aus der Aufgabendefinition verwenden. Fügen Sie für Ihre `tls`-Konfiguration das Zertifikat `arn` für die `awsPcaAuthorityArn`, Ihren `kmsKey` und den `roleArn` Ihrer IAM-Rolle hinzu.
Dieser Service verwendet eine`logConfiguration`, um die Service-Connect-Proxyausgabe von `stdout` und `stderr` zu Amazon CloudWatch Logs zu senden. Diese Rolle zur Ausführung von Aufgaben verfügt nicht über die zusätzlichen Berechtigungen, die für die Erstellung der Protokollgruppe CloudWatch Logs erforderlich sind. Erstellen Sie die Protokollgruppe in CloudWatch Logs mithilfe von AWS-Managementkonsole oder AWS CLI. Es wird empfohlen, diese Protokollgruppe zu erstellen und die CloudWatch Proxyprotokolle in Logs zu speichern. Wenn Sie die Proxyprotokolle nicht an Logs senden möchten, CloudWatch können Sie die entfernen`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. Erstellen eines Service mithilfe der `service-connect-nginx-service.json`-Datei:
```
aws ecs create-service --cluster tutorial --cli-input-json file://service-connect-nginx-service.json
```
Ausgabe:
```
{
"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
}
}
```
Die von Ihnen angegebene `serviceConnectConfiguration` wird in der ersten *Bereitstellung* der Ausgabe angezeigt. Wenn Sie Änderungen am ECS-Service vornehmen, die Änderungen an Aufgaben erfordern, wird von Amazon ECS eine neue Bereitstellung erstellt.
## Schritt 3: Überprüfen der Möglichkeit, eine Verbindung herzustellen
Um zu überprüfen, ob Service Connect konfiguriert ist und funktioniert, führen Sie die folgenden Schritte aus, um von einer externen Anwendung aus eine Verbindung zum Webservice herzustellen. Sehen Sie sich dann die zusätzlichen Metriken an, CloudWatch die der Service Connect-Proxy erstellt.
**So stellen Sie über eine externe Anwendung eine Verbindung mit dem Webservice her**
+ Herstellen einer Verbindung mit der IP-Adresse der Aufgabe und dem Container-Port mithilfe der IP-Adresse der Aufgabe
Verwenden Sie die AWS CLI , um die Aufgaben-ID abzurufen, indem Sie den verwenden`aws ecs list-tasks --cluster tutorial`.
Wenn Ihre Subnetze und Sicherheitsgruppe Datenverkehr aus dem öffentlichen Internet auf dem Port aus der Aufgabendefinition zulassen, können Sie von Ihrem Computer aus eine Verbindung mit der öffentlichen IP-Adresse herstellen. Die öffentliche IP ist jedoch nicht über `describe-tasks` verfügbar. Die Schritte beinhalten also den Zugriff auf Amazon EC2 AWS-Managementkonsole oder das Abrufen der Details der AWS CLI elastic network interface.
In diesem Beispiel verwendet eine Amazon-EC2-Instance in derselben VPC die private IP der Aufgabe. Die Anwendung ist Nginx, aber der `server: envoy`-Header zeigt, dass der Service-Connect-Proxy verwendet wird. Der Service-Connect-Proxy überwacht den Container-Port aus der Aufgabendefinition.
```
$ 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.
```
**So zeigen Sie Service-Connect-Metriken an**
Der Service Connect-Proxy erstellt Anwendungsmetriken (HTTP- HTTP2, gRPC- oder TCP-Verbindung) in CloudWatch Metriken. Wenn Sie die CloudWatch Konsole verwenden, sehen Sie sich die zusätzlichen metrischen Dimensionen von **DiscoveryName**, (**DiscoveryName, ServiceName, ClusterName**) **TargetDiscoveryName**, und (**TargetDiscoveryName, ServiceName, ClusterName**) unter dem Amazon ECS-Namespace an. Weitere Informationen zu diesen Metriken und den Dimensionen finden Sie unter [Verfügbare Metriken anzeigen](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/viewing_metrics_with_cloudwatch.html) im Amazon CloudWatch Logs-Benutzerhandbuch.
# Die Serviceerkennung verwenden, um Amazon-ECS-Services mithilfe von DNS-Namen zu verbinden
Ihr Amazon-ECS-Service kann optional so konfiguriert werden, dass er die Amazon-ECS-Serviceerkennung verwendet. Service Discovery verwendet AWS Cloud Map API-Aktionen, um HTTP- und DNS-Namespaces für Ihre Amazon ECS-Services zu verwalten. Weitere Informationen finden Sie unter [Was ist AWS Cloud Map?](https://docs.aws.amazon.com/cloud-map/latest/dg/Welcome.html) im *AWS Cloud Map -Entwicklerhandbuch*.
Service Discovery ist in den folgenden Regionen verfügbar: AWS
| Name der Region | Region |
| --- | --- |
| USA Ost (Nord-Virginia) | us-east-1 |
| USA Ost (Ohio) | us-east-2 |
| USA West (Nordkalifornien) | us-west-1 |
| USA West (Oregon) | us-west-2 |
| Afrika (Kapstadt) | af-south-1 |
| Asien-Pazifik (Hongkong) | ap-east-1 |
| Asien-Pazifik (Taipeh) | ap-east-2 |
| Asien-Pazifik (Mumbai) | ap-south-1 |
| Asien-Pazifik (Hyderabad) | ap-south-2 |
| Asien-Pazifik (Tokio) | ap-northeast-1 |
| Asien-Pazifik (Seoul) | ap-northeast-2 |
| Asia Pacific (Osaka) | ap-northeast-3 |
| Asien-Pazifik (Singapur) | ap-southeast-1 |
| Asien-Pazifik (Sydney) | ap-southeast-2 |
| Asien-Pazifik (Jakarta) | ap-southeast-3 |
| Asien-Pazifik (Melbourne) | ap-southeast-4 |
| Asien-Pazifik (Malaysia) | ap-southeast-5 |
| Asien-Pazifik (Neuseeland) | ap-southeast-6 |
| Asien-Pazifik (Thailand) | ap-southeast-7 |
| Kanada (Zentral) | ca-central-1 |
| Kanada West (Calgary) | ca-west-1 |
| China (Beijing) | cn-north-1 |
| China (Ningxia) | cn-northwest-1 |
| Europe (Frankfurt) | eu-central-1 |
| Europa (Zürich) | eu-central-2 |
| Europa (Irland) | eu-west-1 |
| Europa (London) | eu-west-2 |
| Europa (Paris) | eu-west-3 |
| Europa (Milan) | eu-south-1 |
| Europa (Stockholm) | eu-north-1 |
| Israel (Tel Aviv) | il-central-1 |
| Europa (Spain) | eu-south-2 |
| Naher Osten (VAE) | me-central-1 |
| Mexiko (Zentral) | mx-central-1 |
| Naher Osten (Bahrain) | me-south-1 |
| Südamerika (São Paulo) | sa-east-1 |
| AWS GovCloud (US-Ost) | us-gov-east-1 |
| AWS GovCloud (US-West) | us-gov-west-1 |
## Konzepte für Serviceerkennung
Die Serviceerkennung umfasst folgende Komponenten:
+ **Serviceerkennungs-Namespace**: Eine logische Gruppe von Serviceerkennungs-Services, die den gleichen Domain-Namen haben, zum Beispiel `example.com`, wo Sie den Datenverkehr hinleiten möchten. Sie können einen Namespace mit einem Aufruf des `aws servicediscovery create-private-dns-namespace`-Befehls oder in der Amazon-ECS-Konsole erstellen. Sie können den `aws servicediscovery list-namespaces`-Befehl zum Anzeigen der zusammenfassenden Informationen über die Namespaces, die vom aktuellen Konto erstellt wurden, verwenden. Weitere Informationen zu den Service Discovery-Befehlen finden Sie unter `[create-private-dns-namespace](https://docs.aws.amazon.com/cli/latest/reference/servicediscovery/create-private-dns-namespace.html)` und `[list-namespaces](https://docs.aws.amazon.com/cli/latest/reference/servicediscovery/list-namespaces.html)` im * AWS CLI Referenzhandbuch AWS Cloud Map (Service Discovery)*.
+ **Serviceerkennung Service**: Ist im Service Discover-Namespace vorhanden und besteht aus dem Servicenamen und der DNS-Konfiguration für den Namespace. Er stellt die folgende Kernkomponente bereit:
+ **Dienstregistrierung**: Ermöglicht es Ihnen, über DNS- oder AWS Cloud Map API-Aktionen nach einem Dienst zu suchen und einen oder mehrere verfügbare Endpunkte wiederherzustellen, die für die Verbindung mit dem Dienst verwendet werden können.
+ **Serviceerkennung-Instance**: Existiert innerhalb des Serviceerkennung-Service und besteht aus den Attributen, die jedem Amazon-ECS-Service im Serviceverzeichnis zugeordnet sind.
+ **Instance-Attribute**: Die folgenden Metadaten werden als benutzerdefinierte Attribute für jeden Amazon-ECS-Service hinzugefügt, der für die Verwendung von Serviceerkennung konfiguriert ist:
+ **`AWS_INSTANCE_IPV4`**— Für einen `A` Datensatz die IPv4 Adresse, die Route 53 als Antwort auf DNS-Abfragen AWS Cloud Map zurückgibt und die zurückgibt, wenn beispielsweise Instanzdetails entdeckt werden. `192.0.2.44`
+ **`AWS_INSTANCE_IPV6`**— Für einen `AAAA` Datensatz die IPv6 Adresse, die Route 53 als Antwort auf DNS-Abfragen AWS Cloud Map zurückgibt und die zurückgibt, wenn Instanzdetails gefunden ` 2001:0db8:85a3:0000:0000:abcd:0001:2345` werden, z. B. Sowohl `AWS_INSTANCE_IPv4` und `AWS_INSTANCE_IPv6` werden für Amazon-ECS-DualStack-Services hinzugefügt. Nur `AWS_INSTANCE_IPv6` wird für Dienste hinzugefügt, die IPv6 nur Amazon ECS anbieten.
+ **`AWS_INSTANCE_PORT`**: Der Port-Wert, der dem Serviceerkennung-Service zugeordnet ist.
+ **`AVAILABILITY_ZONE`**: Die Availability Zone, in der die Aufgabe gestartet wurde. Bei Aufgaben, die EC2 verwenden, ist dies die Availability Zone, in der die Container-Instance besteht. Bei Aufgaben, die Fargate verwenden, ist dies die Availability Zone, in der die Elastic-Network-Schnittstelle besteht.
+ **`REGION`**: Die Region, in der sich die Aufgabe befindet.
+ **`ECS_SERVICE_NAME`**: Der Name des Amazon-ECS-Services, zu dem die Aufgabe gehört.
+ **`ECS_CLUSTER_NAME`**: Der Name des Amazon ECS-Clusters, zu dem die Aufgabe gehört.
+ **`EC2_INSTANCE_ID`**: Die ID der Container-Instance, in der die Aufgabe platziert wurde. Dieses benutzerdefinierte Attribut wird nicht hinzugefügt, wenn die Aufgabe Fargate verwendet.
+ **`ECS_TASK_DEFINITION_FAMILY`**: Die Aufgabendefinitionsfamilie, die die Aufgabe verwendet.
+ **`ECS_TASK_SET_EXTERNAL_ID`**: Wenn eine Aufgabe für eine externe Bereitstellung erstellt und einer Serviceerkennung-Registrierung zugeordnet wird, dann enthält das Attribut `ECS_TASK_SET_EXTERNAL_ID` die externe ID des Aufgabensatzes.
+ **Amazon ECS-Zustandsprüfungen**: Amazon ECS führt regelmäßige Zustandsprüfungen auf Container-Ebene durch. Wenn ein Endpunkt die Zustandsprüfung nicht besteht, wird er aus dem DNS-Routing entfernt und als fehlerhaft markiert.
## Überlegungen zu Serviceerkennung
Bei der Verwendung der Serviceerkennung sollte Folgendes berücksichtigt werden:
+ Serviceerkennung wird für Aufgaben auf Fargate unterstützt, die Plattform-Version v1.1.0 oder höher verwenden. Weitere Informationen finden Sie unter [Fargate-Plattformversionen für Amazon ECS](platform-fargate.md).
+ Services, die für die Verwendung von Serviceerkennung konfiguriert sind, haben ein Limit von 1000 Aufgaben pro Service. Dies ist auf eine Service-Quote der Route 53 zurückzuführen.
+ Der Create Service-Workflow in der Amazon ECS-Konsole unterstützt nur die Registrierung von Services in private DNS-Namespaces. Wenn ein AWS Cloud Map privater DNS-Namespace erstellt wird, wird automatisch eine private gehostete Route 53-Zone erstellt.
+ Die VPC DNS-Attribute müssen für eine erfolgreiche DNS-Auflösung konfiguriert werden. Weitere Informationen zum Konfigurieren der Attribute finden Sie unter [DNS-Support für Ihre VPC](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-dns.html#vpc-dns-support) im *Amazon VPC-Benutzerhandbuch*.
+ Amazon ECS unterstützt die Registrierung von Services in gemeinsam genutzten AWS Cloud Map Namespaces nicht.
+ Die für einen Serviceerkennung-Service erstellten DNS-Datensätze werden auch bei Verwendung von öffentlichen Namespaces immer mit der privaten IP-Adresse für die Aufgabe anstelle der öffentlichen IP-Adresse registriert.
+ Serviceerkennung erfordert, dass Aufgaben entweder Netzwerkmodus `awsvpc`, `bridge` oder `host` angeben (`none` wird nicht unterstützt).
+ Wenn die Service-Aufgabendefinition den `awsvpc`-Netzwerkmodus verwendet, können Sie für jede Service-Aufgabe eine beliebige Kombination aus `A`- oder `SRV`-Datensätzen erstellen. Wenn Sie `SRV`-Datensätze verwenden, ist ein Port erforderlich. Sie können zusätzlich `AAAA`-Datensätze erstellen, wenn der Service Dual-Stack-Subnetze verwendet. Wenn der Service IPv6 nur Subnetze verwendet, können Sie keine Datensätze erstellen. `A`
+ Wenn die Service-Aufgabendefinition den Netzwerkmodus `bridge` oder `host` verwendet, wird nur der SRV-Datensatz als DNS-Datensatztyp unterstützt. Erstellen Sie einen SRV-Datensatz für jede Serviceaufgabe. Der SRV-Datensatz muss eine Kombination aus Containername und Container-Port aus der Aufgabendefinition angeben.
+ DNS-Datensätze für einen Service zur Serviceerkennung können innerhalb Ihrer VPC abgefragt werden. Sie verwenden das folgende Format: `.`.
+ Wenn Sie eine DNS-Abfrage nach dem Namen des Services durchführen, geben `A`- und `AAAA`-Datensätze eine Reihe von IP-Adressen zurück, die Ihren Aufgaben entsprechen. `SRV`-Datensätze geben einen Satz von IP-Adressen und Ports für jede Aufgabe zurück.
+ Wenn Sie über acht oder weniger fehlerfreie Datensätze verfügen, beantwortet Route 53 alle DNS-Abfragen mit allen fehlerfreien Datensätzen.
+ Wenn alle Datensätze fehlerhaft sind, beantwortet Route 53 DNS-Abfragen mit bis zu acht fehlerhaften Datensätzen.
+ Sie können die Serviceerkennung für einen Service konfigurieren, der sich hinter einem Load Balancer befindet, aber der Serviceerkennungsverkehr wird immer an die Aufgabe und nicht an den Load Balancer weitergeleitet.
+ Serviceerkennung unterstützt die Verwendung von Classic Load Balancers nicht.
+ Wir empfehlen Ihnen, Zustandsprüfungen auf Containerebene zu verwenden, die von Amazon ECS für Ihren Service zur Serviceerkennung verwaltet werden.
+ **HealthCheckCustomConfig**—Amazon ECS verwaltet Gesundheitschecks in Ihrem Namen. Amazon ECS verwendet Informationen aus Container- und Zustandsprüfungen sowie Ihren Aufgabenstatus, um den Zustand mit AWS Cloud Map zu aktualisieren. Dies wird beim Erstellen Ihres Serviceerkennung-Service mit dem Parameter `--health-check-custom-config` festgelegt. Weitere Informationen finden Sie unter [HealthCheckCustomConfig](https://docs.aws.amazon.com/cloud-map/latest/api/API_HealthCheckCustomConfig.html) in der *AWS Cloud Map -API-Referenz*.
+ Die AWS Cloud Map Ressourcen, die bei der Nutzung von Service Discovery erstellt werden, müssen manuell bereinigt werden.
+ Aufgaben und Instances werden als `UNHEALTHY` registriert, bis die Container-Zustandsprüfungen einen Wert zurückgeben. Wenn die Zustandsprüfungen bestanden wurden, wird der Status auf `HEALTHY` aktualisiert. Wenn die Container-Zustandsprüfungen fehlschlagen, wird die Registrierung der Serviceerkennungs-Instance aufgehoben.
## Serviceerkennung-Preisgestaltung
Den Kunden, die Amazon-ECS-Serviceerkennung nutzen, werden die Route 53-Ressourcen und die AWS Cloud Map -Discovery API-Operationen berechnet. Dies umfasst die Kosten für das Erstellen der von Route 53 gehosteten Zonen und Abfragen der Service-Registry. Weitere Informationen finden Sie unter [AWS Cloud Map -Preisgestaltung](https://docs.aws.amazon.com/cloud-map/latest/dg/cloud-map-pricing.html) im *AWS Cloud Map -Entwicklerhandbuch*.
Amazon ECS führt Integritätsprüfungen auf Containerebene durch und macht sie für AWS Cloud Map benutzerdefinierte API-Operationen zur Integritätsprüfung verfügbar. Dies wird den Kunden derzeit ohne Mehrkosten zur Verfügung gestellt. Wenn Sie zusätzliche Zustandsprüfungen für öffentlich zugängliche Aufgaben konfigurieren, werden Ihnen diese Zustandsprüfungen in Rechnung gestellt.
# Erstellen eines Amazon-ECS-Service, der Serviceerkennung verwendet
Erfahren Sie, wie Sie mit der AWS CLI einen Service erstellen, der eine Fargate-Aufgabe enthält, die die Serviceerkennung verwendet.
Eine Liste AWS-Regionen dieser Support-Serviceanfragen finden Sie unter[Die Serviceerkennung verwenden, um Amazon-ECS-Services mithilfe von DNS-Namen zu verbinden](service-discovery.md).
Weitere Informationen über Regionen, die Fargate unterstützen, finden Sie unter [Unterstützte Regionen für Amazon ECS auf AWS Fargate](AWS_Fargate-Regions.md).
**Anmerkung**
Sie können Dual-Stack-Service-Endpunkte verwenden, um mit Amazon ECS über die AWS CLI SDKs, und die Amazon ECS-API sowohl über als auch IPv4 zu interagieren. IPv6 Weitere Informationen finden Sie unter [Verwenden von Dual-Stack-Endpunkten in Amazon ECS](dual-stack-endpoint.md).
## Voraussetzungen
Bevor Sie mit diesem Tutorial beginnen, stellen Sie sicher, dass die folgenden Voraussetzungen erfüllt sind:
+ Die neueste Version von AWS CLI ist installiert und konfiguriert. Weitere Informationen finden Sie unter [Installieren oder Aktualisierung auf die neueste Version der AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ Die unter [Einrichtung für die Verwendung von Amazon ECS](get-set-up-for-amazon-ecs.md) beschriebenen Schritte sind abgeschlossen.
+ Ihr IAM-Benutzer besitzt die im [AmazonECS\$1 FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess)-IAM-Richtlinienbeispiel angegebenen Berechtigungen.
+ Sie haben mindestens eine VPC und eine Sicherheitsgruppe erstellt. Weitere Informationen finden Sie unter [Erstellen einer Virtual Private Cloud](get-set-up-for-amazon-ecs.md#create-a-vpc).
## Schritt 1: Erstellen Sie die Service Discovery-Ressourcen in AWS Cloud Map
Führen Sie die folgenden Schritte aus, um Ihren Service-Discovery-Namespace und Service zur Serviceerkennung zu erstellen:
1. Erstellen Sie einen privaten Namespace für die Serviceerkennung der Cloud Map. In diesem Beispiel wird ein Namespace mit dem Namen `tutorial` erstellt. *vpc-abcd1234*Ersetzen Sie es durch die ID einer Ihrer vorhandenen VPCs.
```
aws servicediscovery create-private-dns-namespace \
--name tutorial \
--vpc vpc-abcd1234
```
Die Ausgabe dieses Befehls sieht wie folgt aus.
```
{
"OperationId": "h2qe3s6dxftvvt7riu6lfy2f6c3jlhf4-je6chs2e"
}
```
1. Überprüfen Sie mithilfe der `OperationId` aus der Ausgabe des vorherigen Schritts, ob der private Namespace erfolgreich erstellt wurde. Notieren Sie sich die Namespace-ID, da Sie sie in nachfolgenden Befehlen verwenden.
```
aws servicediscovery get-operation \
--operation-id h2qe3s6dxftvvt7riu6lfy2f6c3jlhf4-je6chs2e
```
Die Ausgabe sieht wie folgt aus.
```
{
"Operation": {
"Id": "h2qe3s6dxftvvt7riu6lfy2f6c3jlhf4-je6chs2e",
"Type": "CREATE_NAMESPACE",
"Status": "SUCCESS",
"CreateDate": 1519777852.502,
"UpdateDate": 1519777856.086,
"Targets": {
"NAMESPACE": "ns-uejictsjen2i4eeg"
}
}
}
```
1. Erstellen Sie mithilfe der `NAMESPACE`-ID aus der Ausgabe des vorherigen Schritts einen Service zur Serviceerkennung. In diesem Beispiel wird ein Service mit dem Namen `myapplication` erstellt. Notieren Sie sich die Service-ID und den ARN, da Sie sie in nachfolgenden Befehlen verwenden.
```
aws servicediscovery create-service \
--name myapplication \
--dns-config "NamespaceId="ns-uejictsjen2i4eeg",DnsRecords=[{Type="A",TTL="300"}]" \
--health-check-custom-config FailureThreshold=1
```
Die Ausgabe sieht wie folgt aus.
```
{
"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"
}
}
```
## Schritt 2: Erstellen der Amazon-ECS-Ressourcen
Führen Sie die folgenden Schritte aus, um Ihren Amazon-ECS-Cluster, die Definition der Aufgabe und den Service zu erstellen:
1. Erstellen Sie einen Amazon-ECS-Cluster. In diesem Beispiel wird ein Cluster mit dem Namen `tutorial` erstellt.
```
aws ecs create-cluster \
--cluster-name tutorial
```
1. Registrieren Sie eine Aufgabendefinition, die mit Fargate kompatibel ist und den `awsvpc`-Netzwerkmodus verwendet. Dazu gehen Sie wie folgt vor:
1. Erstellen Sie eine Datei mit dem Namen `fargate-task.json` mit dem Inhalt der folgenden Aufgabendefinition.
```
{
"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. Registrieren Sie die Aufgabendefinition mithilfe von `fargate-task.json`.
```
aws ecs register-task-definition \
--cli-input-json file://fargate-task.json
```
1. Erstellen Sie einen ECS Service, indem Sie die folgenden Schritte ausführen:
1. Erstellen Sie eine Datei mit dem Namen `ecs-service-discovery.json`, die den Inhalt des ECS-Services enthält, den Sie erstellen wollen. Dieses Beispiel verwendet die Aufgabendefinition, die im vorherigen Schritt erstellt wurde. Ein `awsvpcConfiguration` ist erforderlich, da die Beispiel-Aufgabendefinition den `awsvpc`-Netzwerkmodus verwendet.
Wenn Sie den ECS-Service erstellen, geben Sie Fargate und die `LATEST`-Plattformversion an, die Serviceerkennung unterstützt. Wenn der Service zur Serviceerkennung in AWS Cloud Map erstellt wird, ist `registryArn` der zurückgegebene ARN. Die `securityGroups` und `subnets` muss zu der VPC gehören, die zum Erstellen des Cloud Map-Namespaces verwendet wird. Sie können die Sicherheitsgruppe und das Subnetz IDs von der Amazon VPC-Konsole abrufen.
```
{
"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. Erstellen Sie Ihren ECS-Service mithilfe von `ecs-service-discovery.json`.
```
aws ecs create-service \
--cli-input-json file://ecs-service-discovery.json
```
## Schritt 3: Überprüfen Sie Service Discovery in AWS Cloud Map
Sie können überprüfen, ob alles ordnungsgemäß erstellt wurde, indem Sie Ihre Serviceerkennung-Informationen abfragen. Nachdem die Diensterkennung konfiguriert wurde, können Sie entweder AWS Cloud Map API-Operationen verwenden oder `dig` von einer Instanz in Ihrer VPC aus aufrufen. Dazu gehen Sie wie folgt vor:
1. Listen Sie mithilfe der Serviceerkennung-Service-ID die Service-Discovery-Instances auf. Notieren Sie sich die Instance-ID (fett markiert) für die Ressourcen-Bereinigung.
```
aws servicediscovery list-instances \
--service-id srv-utcrh6wavdkggqtk
```
Die Ausgabe sieht wie folgt aus.
```
{
"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. Verwenden Sie den Serviceerkennung-Namespace, den Service und zusätzliche Parameter wie den ECS-Clusternamen, um Details zu den Service-Discovery-Instances abzufragen.
```
aws servicediscovery discover-instances \
--namespace-name tutorial \
--service-name myapplication \
--query-parameters ECS_CLUSTER_NAME=tutorial
```
1. Die DNS-Einträge, die in der von Route 53 gehosteten Zone für den Service zur Serviceerkennung erstellt wurden, können mit den folgenden AWS CLI -Befehlen abgefragt werden:
1. Rufen Sie mithilfe der Namespace-ID Informationen zum Namespace ab, die die von Route 53 gehostete Zonen-ID enthalten.
```
aws servicediscovery \
get-namespace --id ns-uejictsjen2i4eeg
```
Die Ausgabe sieht wie folgt aus.
```
{
"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. Verwenden Sie die ID der gehosteten Route-53-Zone aus dem vorherigen Schritt (siehe fett gedruckten Text), um den Ressourcendatensatz für die gehostete Zone abzurufen.
```
aws route53 list-resource-record-sets \
--hosted-zone-id Z35JQ4ZFDRYPLV
```
1. Sie können den DNS auch von einer Instance innerhalb Ihrer VPC mit `dig` abfragen.
```
dig +short myapplication.tutorial
```
## Schritt 4: Bereinigen
Wenn Sie mit diesem Tutorial fertig sind, bereinigen Sie die zugeordneten Ressourcen, um Gebühren für ungenutzte Ressourcen zu vermeiden. Dazu gehen Sie wie folgt vor:
1. Deregistrieren Sie die Serviceerkennung Service-Instances mithilfe der zuvor notierten Service-ID und Instance-ID.
```
aws servicediscovery deregister-instance \
--service-id srv-utcrh6wavdkggqtk \
--instance-id 16becc26-8558-4af1-9fbd-f81be062a266
```
Die Ausgabe sieht wie folgt aus.
```
{
"OperationId": "xhu73bsertlyffhm3faqi7kumsmx274n-jh0zimzv"
}
```
1. Überprüfen Sie mithilfe von `OperationId` aus der Ausgabe des vorherigen Schritts, ob die Serviceerkennung-Instances erfolgreich deregistriert wurden.
```
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. Löschen Sie den Service zur Serviceerkennung unter Verwendung der Service-ID.
```
aws servicediscovery delete-service \
--id srv-utcrh6wavdkggqtk
```
1. Löschen Sie den Serviceerkennung-Namespace mithilfe der Namespace-ID.
```
aws servicediscovery delete-namespace \
--id ns-uejictsjen2i4eeg
```
Die Ausgabe sieht wie folgt aus.
```
{
"OperationId": "c3ncqglftesw4ibgj5baz6ktaoh6cg4t-jh0ztysj"
}
```
1. Überprüfen Sie mithilfe der `OperationId` aus der vorherigen Ausgabe des vorherigen Schritts, ob der Serviceerkennung-Namespace erfolgreich gelöscht wurde.
```
aws servicediscovery get-operation \
--operation-id c3ncqglftesw4ibgj5baz6ktaoh6cg4t-jh0ztysj
```
Die Ausgabe sieht wie folgt aus.
```
{
"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. Aktualisieren Sie die gewünschte Anzahl für den Amazon-ECS-Service auf `0`. Sie müssen dies tun, um den Service im nächsten Schritt zu löschen.
```
aws ecs update-service \
--cluster tutorial \
--service ecs-service-discovery \
--desired-count 0
```
1. Löschen Sie den Amazon-ECS-Service.
```
aws ecs delete-service \
--cluster tutorial \
--service ecs-service-discovery
```
1. Löschen Sie den Amazon-ECS-Cluster.
```
aws ecs delete-cluster \
--cluster tutorial
```
# Verwenden Sie Amazon VPC Lattice, um Ihre Amazon ECS-Services zu verbinden, zu beobachten und zu sichern
Amazon VPC Lattice ist ein vollständig verwalteter Anwendungsnetzwerkservice, der es Amazon ECS-Kunden ermöglicht, Anwendungen, die auf AWS Rechendiensten und Konten basieren, zu beobachten VPCs, zu sichern und zu überwachen — ohne dass Codeänderungen erforderlich sind.
VPC Lattice verwendet Zielgruppen, bei denen es sich um eine Sammlung von Rechenressourcen handelt. Diese Ziele führen Ihre Anwendung oder Ihren Service aus und können Amazon EC2 EC2-Instances, IP-Adressen, Lambda-Funktionen und Application Load Balancer sein. Durch die Zuordnung ihrer Amazon ECS-Services zu einer VPC Lattice-Zielgruppe können Kunden jetzt Amazon ECS-Aufgaben als IP-Ziele in VPC Lattice aktivieren. Amazon ECS registriert Aufgaben automatisch für die Zielgruppe von VPC Lattice, wenn Aufgaben für den registrierten Service gestartet werden.
**Anmerkung**
Wenn Sie fünf VPC-Lattice-Konfigurationen verwenden, kann Ihre Bereitstellungszeit etwas länger sein als bei Verwendung weniger Konfigurationen.
Eine Listener-Regel wird verwendet, um Datenverkehr an eine bestimmte Zielgruppe weiterzuleiten, wenn die Bedingungen erfüllt sind. Ein Listener prüft Verbindungsanforderungen mit dem Protokoll auf dem von Ihnen konfigurierten Port. Ein Service leitet Anfragen auf der Grundlage der Regeln, die Sie bei der Konfiguration Ihres Listeners definiert haben, an seine registrierten Ziele weiter.
Amazon ECS ersetzt eine Aufgabe auch automatisch, wenn sie gemäß den VPC-Lattice-Zustandsprüfungen fehlerhaft wird. Sobald Amazon ECS-Kunden mit VPC Lattice verbunden sind, können sie auch viele andere rechnerübergreifende Konnektivitäts-, Sicherheits- und Observability-Funktionen in VPC Lattice nutzen, wie z. B. die Verbindung zu Diensten über Cluster und Konten mit AWS Resource Access Manager IAM-Integration für Autorisierung und Authentifizierung sowie erweiterte Funktionen zur Datenverkehrsverwaltung. VPCs
Amazon-ECS-Kunden können VPC Lattice wie folgt nutzen:
+ Höhere Entwicklerproduktivität – VPC Lattice steigert die Entwicklerproduktivität, da Sie sich auf die Entwicklung von Features konzentrieren können, während VPC Lattice die Netzwerk-, Sicherheits- und Beobachtbarkeitsherausforderungen auf allen Computerplattformen einheitlich bewältigt.
+ Bessere Sicherheitslage – Mit VPC Lattice können Ihre Entwickler die Kommunikation zwischen Anwendungen und Rechenplattformen einfach authentifizieren und sichern, Verschlüsselung bei der Übertragung erzwingen und detaillierte Zugriffskontrollen mit Authentifizierungsrichtlinien von VPC Lattice anwenden. Auf diese Weise können Sie eine stärkere Sicherheitshaltung einführen, die branchenweit führende regulatorische und Compliance-Anforderungen erfüllt.
+ Verbesserte Skalierbarkeit und Belastbarkeit von Anwendungen – Mit VPC Lattice können Sie ein Netzwerk bereitgestellter Anwendungen mit Features wie pfad-, header- und methodenbasiertem Routing, Authentifizierung, Autorisierung und Überwachung erstellen. Diese Vorteile werden ohne zusätzlichen Ressourcenaufwand für Workloads bereitgestellt und können Bereitstellungen mit mehreren Clustern unterstützen, die Millionen von Anfragen pro Sekunde generieren, ohne dass die Latenz signifikant erhöht wird.
+ Flexibilität bei der Bereitstellung mit heterogener Infrastruktur – VPC Lattice bietet konsistente Features für alle Datenverarbeitungs-Services wie Amazon ECS, Fargate, Amazon EC2, Amazon EKS und Lambda und gibt Ihrem Unternehmen die Flexibilität, die passende Infrastruktur für jede Anwendung auszuwählen.
## So funktioniert VPC Lattice mit anderen Amazon-ECS-Services
Die Verwendung von VPC Lattice mit Amazon ECS kann die Art und Weise, wie Sie andere Amazon-ECS-Services nutzen, ändern, während andere unverändert bleiben.
**Application Load Balancer**
Sie müssen keinen spezifischen Application Load Balancer mehr für die Verwendung mit dem Zielgruppentyp Application Load Balancer in VPC Lattice erstellen, der dann mit dem Amazon-ECS-Service verknüpft ist. Sie müssen Ihren Amazon-ECS-Service stattdessen nur mit einer VPC-Lattice-Zielgruppe konfigurieren. Sie können sich auch weiterhin dafür entscheiden, Application Load Balancer gleichzeitig mit Amazon ECS zu verwenden.
**Fortlaufende Amazon-ECS-Bereitstellungen**
Nur fortlaufende Bereitstellungen von Amazon ECS funktionieren mit VPC Lattice, und Amazon ECS überträgt Aufgaben während der Bereitstellung sicher in Services und entfernt sie aus diesen. Codebereitstellung und -bereitstellungen werden nicht unterstützt. Blue/Green
Weitere Informationen zu VPC Lattice finden Sie im [Benutzerhandbuch für Amazon VPC Lattice](https://docs.aws.amazon.com/vpc-lattice/latest/ug/what-is-vpc-lattice.html).
# Einen Service erstellen, der VPC Lattice verwendet
Sie können entweder das AWS-Managementkonsole oder das verwenden AWS CLI , um einen Service mit VPC Lattice zu erstellen.
## Voraussetzungen
Bevor Sie mit diesem Tutorial beginnen, stellen Sie sicher, dass die folgenden Voraussetzungen erfüllt sind:
+ Die neueste Version von AWS CLI ist installiert und konfiguriert. Weitere Informationen finden Sie unter [Installieren der AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html).
**Anmerkung**
Sie können Dual-Stack-Service-Endpunkte verwenden, um mit Amazon ECS über die AWS CLI SDKs, und die Amazon ECS-API sowohl über als auch IPv4 zu interagieren. IPv6 Weitere Informationen finden Sie unter [Verwenden von Dual-Stack-Endpunkten in Amazon ECS](dual-stack-endpoint.md).
+ Die unter [Einrichtung für die Verwendung von Amazon ECS](get-set-up-for-amazon-ecs.md) beschriebenen Schritte sind abgeschlossen.
+ Ihr IAM-Benutzer besitzt die im [AmazonECS\$1 FullAccess](security-iam-awsmanpol.md#security-iam-awsmanpol-AmazonECS_FullAccess)-IAM-Richtlinienbeispiel angegebenen Berechtigungen.
## Erstellen Sie einen Service, der VPC Lattice verwendet, mit dem AWS-Managementkonsole
Gehen Sie wie folgt vor, um einen Service mit VPC Lattice mithilfe der AWS-Managementkonsole zu erstellen.
1. [Öffnen Sie die Konsole auf Version 2. https://console.aws.amazon.com/ecs/](https://console.aws.amazon.com/ecs/v2)
1. Klicken Sie im Navigationsbereich auf **Cluster**.
1. Wählen Sie auf der **Cluster**-Seite den Cluster aus, in dem Sie den Service erstellen möchten.
1. Wählen Sie auf der Registerkarte **Services** die Option **Create** (Erstellen) aus.
Wenn Sie noch nie einen Service erstellt haben, folgen Sie den Schritten unter [Amazon-ECS-Service mithilfe der Konsole erstellen](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service-console-v2.html). Fahren Sie dann mit diesen Schritten fort, wenn Sie den Abschnitt VPC Lattice erreichen.
1. Wählen Sie **VPC Lattice einschalten**, indem Sie die Schaltfläche aktivieren.
1. Um eine bestehende Rolle zu verwenden, wählen Sie für die **ECS-Infrastrukturrolle für Amazon ECS** eine Rolle aus, die Sie bereits erstellt haben, um sie bei der Erstellung der VPC-Lattice-Zielgruppe zu verwenden. Um eine neue Rolle zu erstellen, wählen Sie **ECS-Infrastrukturrolle erstellen** aus.
1. Wählen Sie die **VPC** aus.
Die **VPC** hängt vom Netzwerkmodus ab, den Sie bei der Registrierung Ihrer Aufgabendefinition ausgewählt haben. Wenn Sie den `host`- oder `network`-Modus mit EC2 verwenden, wählen Sie Ihre VPC aus.
Für den `awsvpc`-Modus wird die VPC automatisch basierend auf der VPC ausgewählt, die Sie unter **Netzwerk** ausgewählt haben, und kann nicht geändert werden.
1. Wählen Sie unter **Zielgruppen** die Zielgruppe(n) aus. Sie müssen mindestens eine Zielgruppe auswählen und können maximal fünf haben. Um zusätzliche Zielgruppen hinzuzufügen, wählen Sie **Zielgruppe hinzufügen** aus. Wählen Sie den **Port-Namen**, **das Protokoll** und den **Port** für jede gewählte Zielgruppe aus. Zum Löschen einer Zielgruppe, wählen Sie **Entfernen** aus.
**Anmerkung**
Wenn Sie bestehende Zielgruppen hinzufügen möchten, müssen Sie die AWS CLI verwenden. *Anweisungen zum Hinzufügen von Zielgruppen mithilfe von finden Sie unter [register-targets](https://docs.aws.amazon.com/cli/latest/reference/vpc-lattice/register-targets.html) in der AWS Command Line Interface Referenz. AWS CLI*
Obwohl einem VPC-Lattice-Service mehrere Zielgruppen zugeordnet werden können, kann jede Zielgruppe jeweils nur einem einzigen Service hinzugefügt werden.
Um einen Dienst in einer IPv6 Nur-Konfiguration zu erstellen, wählen Sie Zielgruppen mit einem IP-Adresstyp von. `IPv6`
1. An dieser Stelle navigieren Sie zur VPC-Lattice-Konsole, um mit der Einrichtung fortzufahren. Hier nehmen Sie Ihre neuen Zielgruppen in die Listener-Standardaktion oder in die Regeln eines bestehenden VPC-Lattice-Services auf.
Weitere Informationen finden Sie unter [Listener-Regeln für Ihren VPC-Lattice-Service](https://docs.aws.amazon.com/vpc-lattice/latest/ug/listener-rules.html).
**Wichtig**
Sie müssen das Präfix `vpc-lattice` der Regel für eingehenden Datenverkehr für Ihre Sicherheitsgruppe zulassen. Andernfalls schlagen Aufgaben und Zustandsprüfungen fehl.
## Erstellen Sie einen Service, der VPC Lattice verwendet, mit dem AWS CLI
Verwenden Sie den AWS CLI , um einen Service mit VPC Lattice zu erstellen. Ersetzen Sie jeden *user input placeholder* durch Ihre Informationen.
1. Erstellen einer Zielgruppen-Konfigurationsdatei Das folgende Beispiel heißt `tg-config.json`.
```
{
"ipAddressType": "IPV4",
"port": 443,
"protocol": "HTTPS",
"protocolVersion": "HTTP1",
"vpcIdentifier": "vpc-f1663d9868EXAMPLE"
}
```
1. Verwenden Sie den folgenden Befehl, um eine VPC-Lattice-Zielgruppe zu erstellen.
```
aws vpc-lattice create-target-group \
--name my-lattice-target-group-ip \
--type IP \
--config file://tg-config.json
```
**Anmerkung**
Um einen Dienst in einer IPv6 Nur-Konfiguration zu erstellen, erstellen Sie Zielgruppen mit einem IP-Adresstyp von. `IPv6` Weitere Informationen finden Sie unter [create-target-group](https://docs.aws.amazon.com/cli/latest/reference/vpc-lattice/create-target-group.html) in der Referenz zum *AWS CLI -Befehl*.
Beispielausgabe:
```
{
"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. Die folgende JSON-Datei mit dem Namen *ecs-service-vpc-lattice.json* ist ein Beispiel, das verwendet wird, um einen Amazon ECS-Service an eine VPC Lattice-Zielgruppe anzuhängen. Der `portName` im Beispiel unten ist derselbe, den Sie im `name`-Feld der `portMappings`-Eigenschaft Ihrer Aufgabendefinition definiert haben.
```
{
"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"
}
```
Verwenden Sie den folgenden Befehl, um einen Amazon-ECS-Service zu erstellen und ihn mithilfe des obigen JSON-Beispiels an die VPC-Lattice-Zielgruppe anzuhängen.
```
aws ecs create-service \
--cluster clusterName \
--serviceName ecs-service-vpc-lattice \
--cli-input-json file://ecs-service-vpc-lattice.json
```
**Anmerkung**
VPC Lattice wird auf Amazon ECS Anywhere nicht unterstützt.