Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Erste Schritte mit App Mesh
**Wichtig**
Hinweis zum Ende des Supports: Am 30. September 2026 AWS wird der Support für eingestellt. AWS App Mesh Nach dem 30. September 2026 können Sie nicht mehr auf die AWS App Mesh Konsole oder die Ressourcen zugreifen. AWS App Mesh Weitere Informationen finden Sie in diesem Blogbeitrag [Migration von AWS App Mesh zu Amazon ECS Service Connect](https://aws.amazon.com/blogs/containers/migrating-from-aws-app-mesh-to-amazon-ecs-service-connect).
Sie können App Mesh mit Anwendungen verwenden, die Sie auf Amazon ECS, Kubernetes (die Sie auf Ihren eigenen Amazon EC2-Instances bereitstellen oder auf Amazon EKS ausführen) und Amazon EC2 bereitstellen. Um mit App Mesh zu beginnen, wählen Sie einen der Dienste aus, für die Sie Anwendungen bereitgestellt haben und die Sie mit App Mesh verwenden möchten. Sie können Anwendungen in den anderen Diensten jederzeit so einrichten, dass sie auch mit App Mesh funktionieren, nachdem Sie eine der Anleitungen für die ersten Schritte ausgefüllt haben.
**Topics**
+ [
# Erste Schritte mit AWS App Mesh Amazon ECS
](getting-started-ecs.md)
+ [
# Erste Schritte mit AWS App Mesh und Kubernetes
](getting-started-kubernetes.md)
+ [
# Erste Schritte mit AWS App Mesh Amazon EC2
](getting-started-ec2.md)
+ [
# Beispiele für App Mesh
](examples.md)
# Erste Schritte mit AWS App Mesh Amazon ECS
**Wichtig**
Hinweis zum Ende des Supports: Am 30. September 2026 AWS wird der Support für eingestellt. AWS App Mesh Nach dem 30. September 2026 können Sie nicht mehr auf die AWS App Mesh Konsole oder die Ressourcen zugreifen. AWS App Mesh Weitere Informationen finden Sie in diesem Blogbeitrag [Migration von AWS App Mesh zu Amazon ECS Service Connect](https://aws.amazon.com/blogs/containers/migrating-from-aws-app-mesh-to-amazon-ecs-service-connect).
Dieses Thema hilft Ihnen bei der Verwendung AWS App Mesh mit einem tatsächlichen Service, der auf Amazon ECS ausgeführt wird. Dieses Tutorial behandelt die grundlegenden Funktionen verschiedener App Mesh Mesh-Ressourcentypen.
## Szenario
Gehen Sie zur Veranschaulichung der Verwendung von App Mesh davon aus, dass Sie über eine Anwendung mit den folgenden Eigenschaften verfügen:
+ Besteht aus zwei Diensten mit dem Namen `serviceA` und`serviceB`.
+ Beide Services sind in einem Namespace namens `apps.local` registriert.
+ `ServiceA` kommuniziert mit `serviceB` über HTTP/2, Port 80.
+ Sie haben bereits Version 2 von `serviceB` bereitgestellt und mit dem Namen `serviceBv2` im `apps.local`-Namespace registriert.
Es gelten die folgenden Anforderungen:
+ Sie möchten 75 Prozent des Datenverkehrs von `serviceA` bis `serviceB` und 25 Prozent des Datenverkehrs an `serviceBv2` First weiterleiten. Wenn Sie nur 25 Prozent des Datenverkehrs an senden`serviceBv2`, können Sie überprüfen, ob es fehlerfrei ist, bevor Sie 100 Prozent des Datenverkehrs von senden`serviceA`.
+ Sie möchten in der Lage sein, die Datenverkehrsgewichtung so anzupassen, dass 100 Prozent des Datenverkehrs an `serviceBv2` gehen, sobald sich die Zuverlässigkeit davon erwiesen hat. Sobald der gesamte Datenverkehr an gesendet wurde`serviceBv2`, möchten Sie den Vorgang beenden`serviceB`.
+ Sie möchten für Ihre eigentlichen Dienste keinen bestehenden Anwendungscode oder eine Registrierung zur Serviceerkennung ändern müssen, um die vorherigen Anforderungen zu erfüllen.
Um Ihren Anforderungen gerecht zu werden, entscheiden Sie sich dafür, ein App Mesh Service Mesh mit virtuellen Diensten, virtuellen Knoten, einem virtuellen Router und einer Route zu erstellen. Nach der Implementierung Ihres Meshs aktualisieren Sie Ihre Dienste so, dass sie den Envoy-Proxy verwenden. Nach der Aktualisierung kommunizieren Ihre Services miteinander über den Envoy-Proxy und nicht direkt miteinander.
## Voraussetzungen
**Wichtig**
Hinweis zum Ende des Supports: Am 30. September 2026 AWS wird der Support für eingestellt. AWS App Mesh Nach dem 30. September 2026 können Sie nicht mehr auf die AWS App Mesh Konsole oder die Ressourcen zugreifen. AWS App Mesh Weitere Informationen finden Sie in diesem Blogbeitrag [Migration von AWS App Mesh zu Amazon ECS Service Connect](https://aws.amazon.com/blogs/containers/migrating-from-aws-app-mesh-to-amazon-ecs-service-connect).
+ Ein vorhandenes Verständnis der App Mesh Mesh-Konzepte. Weitere Informationen finden Sie unter [Was ist AWS App Mesh?](what-is-app-mesh.md).
+ Ein bestehendes Verständnis der ECSs Amazon-Konzepte. Weitere Informationen finden Sie unter [Was ist Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html) im Amazon Elastic Container Service Developer Guide.
+ App Mesh unterstützt Linux-Dienste, die mit DNS oder beidem registriert sind. AWS Cloud Map Um dieses Handbuch für Erste Schritte zu verwenden, empfehlen wir, dass Sie über drei vorhandene Services verfügen, die bei DNS registriert sind. Bei den Verfahren in diesem Thema wird davon ausgegangen `serviceA``serviceB`, dass die vorhandenen Dienste benannt sind `serviceBv2` und dass alle Dienste über einen Namespace namens auffindbar sind. `apps.local`
Sie können ein Service-Mesh und seine Ressourcen erstellen, auch wenn die Services nicht vorhanden sind. Sie können das Mesh jedoch erst verwenden, wenn Sie tatsächliche Services bereitgestellt haben. Weitere Informationen zur Serviceerkennung auf Amazon ECS finden Sie unter [Service Discovery](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-discovery.html). Informationen zum Erstellen eines Amazon ECS-Service mit Service Discovery finden Sie unter [Tutorial: Einen Service mithilfe von Service Discovery erstellen](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service-discovery.html). Wenn Sie noch keine Dienste ausführen, können Sie [einen Amazon ECS-Service mit Service Discovery erstellen](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service-discovery.html).
## Schritt 1: Erstellen von einem Mesh und einem virtuellen Service
Ein Service Mesh ist eine logische Begrenzung für den Netzwerkdatenverkehr zwischen den darin vorhandenen Services. Weitere Informationen finden Sie unter [Servicenetze](meshes.md). Ein virtueller Service ist eine Abstraktion eines tatsächlichen Services. Weitere Informationen finden Sie unter [Virtuelle Dienste](virtual_services.md).
Erstellen Sie die folgenden Ressourcen:
+ Ein Mesh mit dem Namen `apps`, da alle Services im Szenario im `apps.local`-Namespace registriert sind.
+ Einen virtuellen Service mit dem Namen `serviceb.apps.local`, da der virtuelle Service einen Service darstellt, der mit diesem Namen gefunden werden kann, und Sie Ihren Code nicht ändern möchten, um auf einen anderen Namen zu verweisen. Ein virtueller Service mit dem Namen `servicea.apps.local` wird in einem späteren Schritt hinzugefügt.
Sie können die AWS-Managementkonsole oder die AWS CLI Version 1.18.116 oder höher oder 2.0.38 oder höher verwenden, um die folgenden Schritte auszuführen. Wenn Sie die verwenden AWS CLI, verwenden Sie den `aws --version` Befehl, um Ihre installierte Version zu überprüfen. AWS CLI Wenn Sie Version 1.18.116 oder höher oder 2.0.38 oder höher nicht installiert haben, müssen Sie die [installieren oder aktualisieren](https://docs.aws.amazon.com/cli/latest/reference/appmesh/cli-chap-install.html). AWS CLI Wählen Sie die Registerkarte für das Werkzeug aus, das Sie verwenden möchten.
------
#### [ AWS-Managementkonsole ]
1. Öffnen Sie bei den ersten Schritten den Assistenten für die erste Ausführung der App Mesh Mesh-Konsole [https://console.aws.amazon.com/appmesh/.](https://console.aws.amazon.com/appmesh/get-started)
1. Geben Sie unter **Mesh name (Mesh-Name)** **apps** ein.
1. Geben Sie unter **Virtual service name (Name des virtuellen Services)** **serviceb.apps.local** ein.
1. Wählen Sie **Next**, um fortzufahren.
------
#### [ AWS CLI ]
1. Erstellen Sie mit dem `[create-mesh](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-mesh.html)`-Befehl ein Mesh.
```
aws appmesh create-mesh --mesh-name apps
```
1. Erstellen Sie einen virtuellen Service mit dem `[create-virtual-service](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-virtual-service.html)`-Befehl.
```
aws appmesh create-virtual-service --mesh-name apps --virtual-service-name serviceb.apps.local --spec {}
```
------
## Schritt 2: Erstellen von einem virtuellen Knoten
Ein virtueller Knoten fungiert als ein logischer Verweis auf einen tatsächlichen Service. Weitere Informationen finden Sie unter [Virtuelle Knoten](virtual_nodes.md).
Erstellen Sie einen virtuellen Knoten mit dem Namen `serviceB`, da einer der virtuellen Knoten den tatsächlichen Service mit dem Namen `serviceB` darstellt. Der tatsächliche Service, den der virtuelle Knoten darstellt, kann über `DNS` mit dem Hostnamen von `serviceb.apps.local` gefunden werden. Alternativ können Sie aktuelle Dienste mithilfe von ermitteln. AWS Cloud Map Der virtuelle Knoten überwacht den Datenverkehr mit dem HTTP/2-Protokoll auf Port 80. Auch andere Protokolle werden unterstützt, ebenso wie Zustandsprüfungen. Sie erstellen virtuelle Knoten für `serviceA` und `serviceBv2` in einem späteren Schritt.
------
#### [ AWS-Managementkonsole ]
1. Geben Sie unter **Virtual node name (Name des virtuellen Knotens)** **serviceB** ein.
1. Wählen Sie unter **Service discovery method (Serviceerkennungsverfahren)** die Option **DNS** aus, und geben Sie **serviceb.apps.local** als **DNS hostname (DNS-Hostname)** ein.
1. **Wählen Sie unter **Listener-Konfiguration** **http2** als **Protokoll** und geben Sie **80** als Port ein.**
1. Wählen Sie **Next**, um fortzufahren.
------
#### [ AWS CLI ]
1. Erstellen Sie eine Datei `create-virtual-node-serviceb.json` mit dem folgenden Inhalt:
```
{
"meshName": "apps",
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http2"
}
}
],
"serviceDiscovery": {
"dns": {
"hostname": "serviceB.apps.local"
}
}
},
"virtualNodeName": "serviceB"
}
```
1. Erstellen Sie den virtuellen Knoten mit dem [create-virtual-node](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-virtual-node.html)Befehl und verwenden Sie dabei die JSON-Datei als Eingabe.
```
aws appmesh create-virtual-node --cli-input-json file://create-virtual-node-serviceb.json
```
------
## Schritt 3: Erstellen von einem virtuellen Router und einer Route
Virtuelle Router routen den Datenverkehr für einen oder mehrere virtuelle Services innerhalb Ihres Meshes. Weitere Informationen erhalten Sie unter [Virtuelle Router](virtual_routers.md) und [Routen](routes.md).
Erstellen Sie die folgenden Ressourcen:
+ Einen virtuellen Router mit dem Namen `serviceB`, da der virtuelle `serviceB.apps.local`-Service keine ausgehende Kommunikation mit einem anderen Service initiiert. Denken Sie daran, dass der virtuelle Service, den Sie zuvor erstellt haben, eine Abstraktion Ihres tatsächlichen `serviceb.apps.local`-Services ist. Der virtuelle Service sendet Datenverkehr an den virtuellen Router. Der virtuelle Router überwacht den Datenverkehr mithilfe des HTTP/2-Protokolls an Port 80. Andere Protokolle werden ebenfalls unterstützt.
+ Eine Route namens `serviceB`. Er leitet 100 Prozent seines Datenverkehrs an den `serviceB` virtuellen Knoten weiter. Die Gewichtung erfolgt in einem späteren Schritt, sobald Sie den `serviceBv2` virtuellen Knoten hinzugefügt haben. Obwohl in diesem Handbuch nicht behandelt, können Sie zusätzliche Filterkriterien für die Route hinzufügen und eine Wiederholungsrichtlinie hinzufügen, damit der Envoy-Proxy mehrere Versuche unternimmt, Datenverkehr an einen virtuellen Knoten zu senden, wenn ein Kommunikationsproblem auftritt.
------
#### [ AWS-Managementkonsole ]
1. Geben Sie für **Virtual router name (Name des virtuellen Routers)** **serviceB** ein.
1. **Wählen Sie unter **Listener-Konfiguration** **http2** als **Protokoll** und geben Sie als Port **80** an.**
1. Geben Sie unter **Route name (Name der Route)** **serviceB** ein.
1. Wählen Sie für **Route type (Routentyp)** die Option **http2**.
1. **Wählen Sie für den **Namen des virtuellen Knotens** unter **Zielkonfiguration** die Option Gewicht aus `serviceB` und geben **100** Sie den Wert ein.**
1. Wählen Sie unter **Konfiguration anpassen** eine **Methode** aus.
1. Wählen Sie **Next**, um fortzufahren.
------
#### [ AWS CLI ]
1. Erstellen Sie einen virtuellen Router.
1. Erstellen Sie eine Datei `create-virtual-router.json` mit dem folgenden Inhalt:
```
{
"meshName": "apps",
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http2"
}
}
]
},
"virtualRouterName": "serviceB"
}
```
1. Erstellen Sie den virtuellen Router mit dem [create-virtual-router](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-virtual-router.html)Befehl und verwenden Sie dabei die JSON-Datei als Eingabe.
```
aws appmesh create-virtual-router --cli-input-json file://create-virtual-router.json
```
1. Erstellen Sie eine Route.
1. Erstellen Sie eine Datei `create-route.json` mit dem folgenden Inhalt:
```
{
"meshName" : "apps",
"routeName" : "serviceB",
"spec" : {
"httpRoute" : {
"action" : {
"weightedTargets" : [
{
"virtualNode" : "serviceB",
"weight" : 100
}
]
},
"match" : {
"prefix" : "/"
}
}
},
"virtualRouterName" : "serviceB"
}
```
1. Erstellen Sie die Route mit dem Befehl [create-route](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-route.html) unter Verwendung der JSON-Datei als Eingabe.
```
aws appmesh create-route --cli-input-json file://create-route.json
```
------
## Schritt 4: Überprüfen und Erstellen
Überprüfen Sie die Einstellungen anhand der vorherigen Anweisungen.
------
#### [ AWS-Managementkonsole ]
Wählen Sie **Edit (Bearbeiten)** aus, wenn Sie Änderungen in einem Abschnitt vornehmen müssen. Sobald Sie mit den Einstellungen zufrieden sind, wählen Sie **Create mesh (Netz erstellen)** aus.
Im Fenster **Status** werden alle erstellten Netzressourcen angezeigt. Sie können die erstellten Ressourcen in der Konsole anzeigen, indem Sie **View mesh (Netz anzeigen)** auswählen.
------
#### [ AWS CLI ]
Überprüfen Sie die Einstellungen des Meshes, das Sie erstellt haben, mit dem Befehl [describe-mesh](https://docs.aws.amazon.com/cli/latest/reference/appmesh/describe-mesh.html).
```
aws appmesh describe-mesh --mesh-name apps
```
Überprüfen Sie die Einstellungen des virtuellen Dienstes, den Sie mit dem [describe-virtual-service](https://docs.aws.amazon.com/cli/latest/reference/appmesh/describe-virtual-service.html)Befehl erstellt haben.
```
aws appmesh describe-virtual-service --mesh-name apps --virtual-service-name serviceb.apps.local
```
Überprüfen Sie die Einstellungen des virtuellen Knotens, den Sie mit dem [describe-virtual-node](https://docs.aws.amazon.com/cli/latest/reference/appmesh/describe-virtual-node.html)Befehl erstellt haben.
```
aws appmesh describe-virtual-node --mesh-name apps --virtual-node-name serviceB
```
Überprüfen Sie die Einstellungen des virtuellen Routers, den Sie mit dem [describe-virtual-router](https://docs.aws.amazon.com/cli/latest/reference/appmesh/describe-virtual-router.html)Befehl erstellt haben.
```
aws appmesh describe-virtual-router --mesh-name apps --virtual-router-name serviceB
```
Überprüfen Sie die Einstellungen der Route, die Sie erstellt haben, mit dem Befehl [describe-route](https://docs.aws.amazon.com/cli/latest/reference/appmesh/describe-route.html).
```
aws appmesh describe-route --mesh-name apps \
--virtual-router-name serviceB --route-name serviceB
```
------
## Schritt 5: Erstellen zusätzlicher Ressourcen
Um das Szenario abzuschließen, müssen Sie:
+ Einen virtuellen Knoten mit dem Namen `serviceBv2` und einen anderen mit dem Namen `serviceA` erstellen. Beide virtuellen Knoten warten auf Anfragen über HTTP/2-Port 80. Konfigurieren Sie für den `serviceA` virtuellen Knoten ein Backend von`serviceb.apps.local`. Der gesamte ausgehende Datenverkehr vom `serviceA` virtuellen Knoten wird an den genannten virtuellen Dienst gesendet. `serviceb.apps.local` Obwohl dies in diesem Handbuch nicht behandelt wird, können Sie auch einen Dateipfad angeben, in den Zugriffsprotokolle für einen virtuellen Knoten geschrieben werden sollen.
+ Erstellen Sie einen zusätzlichen virtuellen Dienst mit dem Namen`servicea.apps.local`, der den gesamten Datenverkehr direkt an den `serviceA` virtuellen Knoten sendet.
+ Aktualisieren Sie die `serviceB`-Route, die Sie in einem vorherigen Schritt erstellt haben, so, dass 75 Prozent des Datenverkehrs an den virtuellen `serviceB`- Knoten und 25 Prozent des Datenverkehrs an den virtuellen `serviceBv2`-Knoten gesendet werden. Im Laufe der Zeit können Sie die Gewichtungen weiter ändern, bis `serviceBv2` 100 Prozent des Datenverkehrs erhält. Sobald der gesamte Datenverkehr an gesendet wurde`serviceBv2`, können Sie den `serviceB` virtuellen Knoten und den eigentlichen Dienst herunterfahren und beenden. Wenn Sie Gewichtungen ändern, erfordert Ihr Code keine Änderung, da sich die Namen des virtuellen `serviceb.apps.local`- und des tatsächlichen Services nicht ändern. Denken Sie daran, dass der virtuelle `serviceb.apps.local`-Service Datenverkehr an den virtuellen Router sendet, der den Datenverkehr an die virtuellen Knoten weiterleitet. Die Serviceerkennungsnamen für die virtuellen Knoten können jederzeit geändert werden.
------
#### [ AWS-Managementkonsole ]
1. Wählen Sie im linken Navigationsbereich **Meshes**.
1. Wählen Sie das `apps`-Mesh aus, das Sie in einem vorherigen Schritt erstellt haben.
1. Wählen Sie im linken Navigationsbereich **Virtual nodes (Virtuelle Knoten)** aus.
1. Wählen Sie **Create virtual node (Virtuellen Knoten erstellen)**.
1. Geben Sie unter **Virtual node name (Name des virtuellen Knotens)** **serviceBv2** ein, wählen Sie für **Service discovery method (Serviceerkennungsverfahren)** die Option **DNS** aus, und geben Sie für den **DNS hostname (DNS-Hostname)** **servicebv2.apps.local** ein.
1. **Wählen Sie für die **Listener-Konfiguration** **http2** als **Protokoll** und geben Sie **80** für Port ein.**
1. Wählen Sie **Create virtual node (Virtuellen Knoten erstellen)**.
1. Wählen Sie erneut **Create virtual node (Virtuellen Knoten erstellen)** aus. Geben Sie „**serviceA**“ als **Virtual node name (Name des virtuellen Knotens)** ein. Wählen Sie als **Service discovery method (Diensterkennungsmethode)** die Option **DNS** ein, und geben Sie als **DNS hostname (DNS-Hostname)** den Wert „**servicea.apps.local**“ ein.
1. Geben Sie bei **Enter a virtual service name (Neuen virtuellen Service-Name eingeben)** unter **New backend (Neues Backend)** den Wert „**serviceb.apps.local**“ ein.
1. Wählen Sie unter **Listener configuration (Listener-Konfiguration)** die Option **http2** für **Protocol (Protokoll)** aus, geben Sie „**80**“ bei **Port** ein, und wählen Sie dann **Create virtual node (Virtuellen Knoten erstellen)** aus.
1. Wählen Sie im linken Navigationsbereich **Virtual routers (Virtuelle Router)** aus, und wählen Sie dann den virtuellen Router `serviceB` aus der Liste aus.
1. Wählen Sie unter **Routes (Routen)** die Route `ServiceB` aus, die Sie in einem vorherigen Schritt erstellt haben, und wählen Sie dann **Edit (Bearbeiten)** aus.
1. Ändern Sie unter **Targets (Ziele)**, **Virtual node name (Name des virtuellen Knotens)** den Wert von **Weight (Gewicht)** für `serviceB` zu **75**.
1. **Wählen Sie **Ziel hinzufügen**, wählen Sie `serviceBv2` aus der Dropdownliste und legen Sie den Wert für Weight auf fest.** **25**
1. Wählen Sie **Speichern**.
1. Wählen Sie im linken Navigationsbereich **Virtual services (Virtuelle Services)** aus, und wählen Sie dann **Create virtual service (Virtuellen Dienst erstellen)** aus.
1. Geben Sie „**servicea.apps.local**“ bei **Virtual service name (Virtueller Dienstname)** ein, wählen Sie **Virtual node (Virtueller Knoten)** als **Provider (Anbieter)**, wählen Sie „`serviceA`“ bei **Virtual node (Virtueller Knoten)** und dann **Create virtual service (Virtuellen Dienst erstellen)** aus.
------
#### [ AWS CLI ]
1. Erstellen Sie den virtuellen Knoten `serviceBv2`.
1. Erstellen Sie eine Datei `create-virtual-node-servicebv2.json` mit dem folgenden Inhalt:
```
{
"meshName": "apps",
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http2"
}
}
],
"serviceDiscovery": {
"dns": {
"hostname": "serviceBv2.apps.local"
}
}
},
"virtualNodeName": "serviceBv2"
}
```
1. Erstellen Sie den virtuellen Knoten.
```
aws appmesh create-virtual-node --cli-input-json file://create-virtual-node-servicebv2.json
```
1. Erstellen Sie den virtuellen Knoten `serviceA`.
1. Erstellen Sie eine Datei `create-virtual-node-servicea.json` mit dem folgenden Inhalt:
```
{
"meshName" : "apps",
"spec" : {
"backends" : [
{
"virtualService" : {
"virtualServiceName" : "serviceb.apps.local"
}
}
],
"listeners" : [
{
"portMapping" : {
"port" : 80,
"protocol" : "http2"
}
}
],
"serviceDiscovery" : {
"dns" : {
"hostname" : "servicea.apps.local"
}
}
},
"virtualNodeName" : "serviceA"
}
```
1. Erstellen Sie den virtuellen Knoten.
```
aws appmesh create-virtual-node --cli-input-json file://create-virtual-node-servicea.json
```
1. Aktualisieren Sie den virtuellen Service `serviceb.apps.local`, den Sie in einem vorherigen Schritt erstellt haben, um seinen Datenverkehr an den virtuellen Router `serviceB` zu senden. Als der virtuelle Service ursprünglich erstellt wurde, sendete er keinen Datenverkehr, da der virtuelle Router `serviceB` noch nicht erstellt war.
1. Erstellen Sie eine Datei `update-virtual-service.json` mit dem folgenden Inhalt:
```
{
"meshName" : "apps",
"spec" : {
"provider" : {
"virtualRouter" : {
"virtualRouterName" : "serviceB"
}
}
},
"virtualServiceName" : "serviceb.apps.local"
}
```
1. Aktualisieren Sie den virtuellen Dienst mit dem [update-virtual-service](https://docs.aws.amazon.com/cli/latest/reference/appmesh/update-virtual-service.html)Befehl.
```
aws appmesh update-virtual-service --cli-input-json file://update-virtual-service.json
```
1. Aktualisieren Sie die Route `serviceB`, die Sie in einem vorherigen Schritt erstellt haben.
1. Erstellen Sie eine Datei `update-route.json` mit dem folgenden Inhalt:
```
{
"meshName" : "apps",
"routeName" : "serviceB",
"spec" : {
"http2Route" : {
"action" : {
"weightedTargets" : [
{
"virtualNode" : "serviceB",
"weight" : 75
},
{
"virtualNode" : "serviceBv2",
"weight" : 25
}
]
},
"match" : {
"prefix" : "/"
}
}
},
"virtualRouterName" : "serviceB"
}
```
1. Aktualisieren Sie die Route mit dem Befehl [update-route](https://docs.aws.amazon.com/cli/latest/reference/appmesh/update-route.html) .
```
aws appmesh update-route --cli-input-json file://update-route.json
```
1. Erstellen Sie den virtuellen Service `serviceA`.
1. Erstellen Sie eine Datei `create-virtual-servicea.json` mit dem folgenden Inhalt:
```
{
"meshName" : "apps",
"spec" : {
"provider" : {
"virtualNode" : {
"virtualNodeName" : "serviceA"
}
}
},
"virtualServiceName" : "servicea.apps.local"
}
```
1. Erstellen Sie den virtuellen Service.
```
aws appmesh create-virtual-service --cli-input-json file://create-virtual-servicea.json
```
------
**Mesh-Zusammenfassung**
Bevor Sie das Service-Mesh erstellt haben, hatten Sie drei aktuelle Services mit den Namen `servicea.apps.local`, `serviceb.apps.local` und `servicebv2.apps.local`. Zusätzlich zu den tatsächlichen Services verfügen Sie jetzt über ein Service-Mesh, das die folgenden Ressourcen enthält, die die tatsächlichen Services darstellen:
+ Zwei virtuelle Services. Der Proxy sendet den gesamten Datenverkehr vom virtuellen Service `servicea.apps.local` über einen virtuellen Router an den virtuellen Service `serviceb.apps.local`.
+ Drei virtuelle Knoten mit den Namen `serviceA`, `serviceB` und `serviceBv2`. Der Envoy-Proxy verwendet die für die virtuellen Knoten konfigurierten Service-Erkennungsinformationen, um die IP-Adressen der tatsächlichen Services zu suchen.
+ Einen virtuellen Router mit einer Route, die den Envoy-Proxy anweist, 75 Prozent des eingehenden Datenverkehrs an den virtuellen Knoten `serviceB` und 25 Prozent des Datenverkehrs an den virtuellen Knoten `serviceBv2` zu leiten.
## Schritt 6: Aktualisieren der Services
Nachdem Sie Ihr Mesh erstellt haben, müssen Sie die folgenden Aufgaben ausführen:
+ Autorisieren Sie den Envoy-Proxy, den Sie mit jeder Amazon ECS-Aufgabe bereitstellen, zum Lesen der Konfiguration eines oder mehrerer virtueller Knoten. Weitere Informationen zum Autorisieren des Proxys finden Sie unter [Proxy-Autorisierung](https://docs.aws.amazon.com/app-mesh/latest/userguide/proxy-authorization.html).
+ Aktualisieren Sie jede Ihrer vorhandenen Amazon ECS-Aufgabendefinitionen, um den Envoy-Proxy zu verwenden.
**Anmeldeinformationen**
Der Envoy-Container benötigt AWS Identity and Access Management Anmeldeinformationen zum Signieren von Anfragen, die an den App Mesh Mesh-Dienst gesendet werden. Für Amazon ECS-Aufgaben, die mit dem Amazon EC2 EC2-Starttyp bereitgestellt werden, können die Anmeldeinformationen aus der [Instance-Rolle](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/instance_IAM_role.html) oder aus einer [Task-IAM-Rolle](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) stammen. Amazon ECS-Aufgaben, die mit Fargate auf Linux-Containern bereitgestellt werden, haben keinen Zugriff auf den Amazon EC2-Metadatenserver, der die Anmeldeinformationen für das Instance-IAM-Profil bereitstellt. Um die Anmeldeinformationen bereitzustellen, müssen Sie allen Aufgaben, die mit dem Containertyp Fargate on Linux bereitgestellt werden, eine IAM-Aufgabenrolle zuordnen.
Wenn eine Aufgabe mit dem Amazon EC2-Starttyp bereitgestellt wird und der Zugriff auf den Amazon EC2-Metadatenserver blockiert ist, wie in der Anmerkung *Wichtig* in [IAM-Rolle für Aufgaben](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) beschrieben, muss der Aufgabe auch eine Aufgaben-IAM-Rolle zugewiesen werden. [Der Rolle, die Sie der Instance oder Aufgabe zuweisen, muss eine IAM-Richtlinie zugeordnet sein, wie unter Proxy-Autorisierung beschrieben.](https://docs.aws.amazon.com/app-mesh/latest/userguide/proxy-authorization.html)
**Um Ihre Aufgabendefinition mit dem zu aktualisieren AWS CLI**
Sie verwenden den Amazon AWS CLI ECS-Befehl [https://docs.aws.amazon.com/cli/latest/reference/ecs/register-task-definition.html](https://docs.aws.amazon.com/cli/latest/reference/ecs/register-task-definition.html). Die folgende Beispielaufgabendefinition zeigt, wie Sie App Mesh für Ihren Dienst konfigurieren.
**Anmerkung**
Die Konfiguration von App Mesh für Amazon ECS über die Konsole ist nicht verfügbar.
### Aufgabendefinition (json)
**Proxykonfiguration**
Um Ihren Amazon ECS-Service für die Verwendung von App Mesh zu konfigurieren, muss die Aufgabendefinition Ihres Services den folgenden Abschnitt zur Proxykonfiguration enthalten. Stellen Sie die Proxy-Konfiguration `type` auf `APPMESH` und `containerName` auf `envoy` ein. Legen Sie die folgenden Eigenschaftswerte entsprechend fest.
`IgnoredUID`
Der Envoy-Proxy leitet keinen Datenverkehr von Prozessen weiter, die diese Benutzer-ID verwenden. Sie können eine beliebige Benutzer-ID für diesen Eigenschaftswert auswählen, diese ID muss jedoch mit der `user`-ID für den Envoy-Container in der Aufgabendefinition übereinstimmen. Diese Übereinstimmung ermöglicht Envoy, eigenen Datenverkehr zu ignorieren, ohne den Proxy zu verwenden. Unsere Beispiele verwenden `1337` für historische Zwecke.
`ProxyIngressPort`
Dies ist der eingehende Port für den Envoy-Proxycontainer. Legen Sie diesen Wert auf `15000` fest.
`ProxyEgressPort`
Dies ist der ausgehende Port für den Envoy-Proxycontainer. Legen Sie diesen Wert auf `15001` fest.
`AppPorts`
Geben Sie alle eingehenden Ports an, auf die Ihre Anwendungscontainer warten. In diesem Beispiel wird vom Anwendungs-Container Port `9080` überwacht. Der angegebene Port muss mit dem Port übereinstimmen, der auf dem virtuellen Knoten-Listener konfiguriert ist.
`EgressIgnoredIPs`
Envoy führt keine Proxy-Weiterleitung an diese IP-Adressen durch. Setzen Sie diesen Wert auf`169.254.170.2,169.254.169.254`, wodurch der Amazon EC2-Metadatenserver und der Amazon ECS-Aufgabenmetadaten-Endpunkt ignoriert werden. Der Metadaten-Endpunkt stellt IAM-Rollen für Aufgabenanmeldedaten bereit. Sie können zusätzliche Adressen hinzufügen.
`EgressIgnoredPorts`
Sie können eine Liste der Ports (mit Kommas als Trennzeichen) hinzufügen. Envoy führt keine Proxy-Weiterleitung an diese Ports durch. Auch wenn Sie keine Ports auflisten, wird Port 22 ignoriert.
Die maximale Anzahl von ausgehenden Ports, die ignoriert werden können, ist 15.
```
"proxyConfiguration": {
"type": "APPMESH",
"containerName": "envoy",
"properties": [{
"name": "IgnoredUID",
"value": "1337"
},
{
"name": "ProxyIngressPort",
"value": "15000"
},
{
"name": "ProxyEgressPort",
"value": "15001"
},
{
"name": "AppPorts",
"value": "9080"
},
{
"name": "EgressIgnoredIPs",
"value": "169.254.170.2,169.254.169.254"
},
{
"name": "EgressIgnoredPorts",
"value": "22"
}
]
}
```
**Envoy-Abhängigkeit des Anwendungs-Containers**
Die Anwendungs-Container in Ihren Aufgabendefinitionen müssen mit dem Starten warten, bis der Envoy-Proxy den Bootstrap-Vorgang durchgeführt hat und gestartet wurde. Um sicherzustellen, dass dies geschieht, legen Sie in jeder Anwendungscontainer-Definition einen `dependsOn` Abschnitt fest, der darauf wartet, dass sich der Envoy-Container als meldet. `HEALTHY` Der folgende Codeblock zeigt ein Beispiel für eine Anwendungs-Containerdefinition mit dieser Abhängigkeit. Alle Eigenschaften im folgenden Beispiel sind erforderlich. Einige Eigenschaftswerte sind ebenfalls erforderlich, andere jedoch schon. *replaceable*
```
{
"name": "appName",
"image": "appImage",
"portMappings": [{
"containerPort": 9080,
"hostPort": 9080,
"protocol": "tcp"
}],
"essential": true,
"dependsOn": [{
"containerName": "envoy",
"condition": "HEALTHY"
}]
}
```
**Envoy-Containerdefinition**
Ihre Amazon ECS-Aufgabendefinitionen müssen ein App Mesh Envoy-Container-Image enthalten.
Alle [unterstützten](https://docs.aws.amazon.com/general/latest/gr/appmesh.html) Regionen können *Region-code* durch jede andere Region als`me-south-1`,,, `ap-east-1` `ap-southeast-3` `eu-south-1``il-central-1`, und `af-south-1` ersetzt werden.
Standard
```
840364872350.dkr.ecr.region-code.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
FIPS-konform
```
840364872350.dkr.ecr.region-code.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod-fips
```
`me-south-1`
Standard
```
772975370895.dkr.ecr.me-south-1.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
`ap-east-1`
Standard
```
856666278305.dkr.ecr.ap-east-1.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
`ap-southeast-3`
Standard
```
909464085924.dkr.ecr.ap-southeast-3.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
`eu-south-1`
Standard
```
422531588944.dkr.ecr.eu-south-1.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
`il-central-1`
Standard
```
564877687649.dkr.ecr.il-central-1.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
`af-south-1`
Standard
```
924023996002.dkr.ecr.af-south-1.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
`Public repository`
Standard
```
public.ecr.aws/appmesh/aws-appmesh-envoy:v1.34.13.0-prod
```
FIPS-konform
```
public.ecr.aws/appmesh/aws-appmesh-envoy:v1.34.13.0-prod-fips
```
**Wichtig**
Nur Version v1.9.0.0-prod oder höher wird für die Verwendung mit App Mesh unterstützt.
Sie müssen das App Mesh Envoy-Container-Image verwenden, bis das Envoy-Projektteam Änderungen zusammenführt, die App Mesh unterstützen. [Weitere Informationen finden Sie in der GitHub Roadmap-Ausgabe.](https://github.com/aws/aws-app-mesh-roadmap/issues/10)
Alle Eigenschaften im folgenden Beispiel sind erforderlich. Einige Eigenschaftswerte sind ebenfalls erforderlich, andere jedoch schon. *replaceable*
**Anmerkung**
Die Envoy-Containerdefinition muss als `essential` gekennzeichnet sein.
Wir empfehlen, dem Envoy-Container `512` CPU-Einheiten und mindestens `64` MiB Arbeitsspeicher zuzuweisen. Bei Fargate ist der niedrigste Wert, den Sie einstellen können, `1024` MiB Arbeitsspeicher.
Der Name des virtuellen Knotens für den Amazon ECS-Service muss auf den Wert der `APPMESH_RESOURCE_ARN` Eigenschaft gesetzt werden. Für diese Eigenschaft ist eine Version `1.15.0` oder eine neuere Version des Envoy-Images erforderlich. Weitere Informationen finden Sie unter [Bild des Gesandten](envoy.md).
Der Wert für die `user`-Einstellung muss mit dem `IgnoredUID`-Wert aus der Proxykonfiguration der Aufgabendefinition übereinstimmen. In diesem Beispiel verwenden wir `1337`.
Die hier gezeigte Integritätsprüfung wartet, bis der Envoy-Container ordnungsgemäß gestartet wurde, bevor Amazon ECS gemeldet wird, dass der Envoy-Container fehlerfrei und bereit für den Start der Anwendungscontainer ist.
Standardmäßig verwendet App Mesh den Namen der Ressource, die Sie in `APPMESH_RESOURCE_ARN` angegeben haben, wenn sich Envoy in Metriken und Ablaufverfolgungen auf sich selbst bezieht. Sie können dieses Verhalten übergehen, indem Sie die `APPMESH_RESOURCE_CLUSTER`-Umgebungsvariable mit Ihrem eigenen Namen festlegen. Für diese Eigenschaft ist eine Version `1.15.0` oder eine neuere Version des Envoy-Images erforderlich. Weitere Informationen finden Sie unter [Bild des Gesandten](envoy.md).
Der folgende Codeblock zeigt ein Beispiel einer Envoy-Containerdefinition.
```
{
"name": "envoy",
"image": "840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod",
"essential": true,
"environment": [{
"name": "APPMESH_RESOURCE_ARN",
"value": "arn:aws:appmesh:us-west-2:111122223333:mesh/apps/virtualNode/serviceB"
}],
"healthCheck": {
"command": [
"CMD-SHELL",
"curl -s http://localhost:9901/server_info | grep state | grep -q LIVE"
],
"startPeriod": 10,
"interval": 5,
"timeout": 2,
"retries": 3
},
"user": "1337"
}
```
**Beispiel für Aufgabendefinitionen**
Die folgenden Amazon ECS-Beispielaufgabendefinitionen zeigen, wie Sie die obigen Beispiele zu einer Aufgabendefinition für zusammenführen können`taskB`. Es werden Beispiele für die Erstellung von Aufgaben für beide Amazon ECS-Starttypen mit oder ohne Verwendung bereitgestellt AWS X-Ray. Ändern Sie die *replaceable* Werte nach Bedarf, um Aufgabendefinitionen für die genannten Aufgaben `taskBv2` und für die Aufgaben `taskA` aus dem Szenario zu erstellen. Geben Sie in Ihrer Proxykonfiguration als Wert für `APPMESH_RESOURCE_ARN` den Namen Ihres Mesh und den Namen des virtuellen Knotens an. Geben Sie zudem als Wert für `AppPorts` eine Liste der Ports an, die von Ihrer Anwendung überwacht werden. Standardmäßig verwendet App Mesh den Namen der Ressource, die Sie in `APPMESH_RESOURCE_ARN` angegeben haben, wenn sich Envoy in Metriken und Ablaufverfolgungen auf sich selbst bezieht. Sie können dieses Verhalten übergehen, indem Sie die `APPMESH_RESOURCE_CLUSTER`-Umgebungsvariable mit Ihrem eigenen Namen festlegen. Alle Eigenschaften in den folgenden Beispielen sind erforderlich. Einige Eigenschaftswerte sind ebenfalls erforderlich, andere jedoch schon*replaceable*.
Wenn Sie eine Amazon ECS-Aufgabe ausführen, wie im Abschnitt Anmeldeinformationen beschrieben, müssen Sie den Beispielen eine bestehende [Task-IAM-Rolle](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) hinzufügen.
**Wichtig**
Fargate muss einen Portwert verwenden, der größer als 1024 ist.
**Example JSON für Amazon ECS-Aufgabendefinition — Fargate auf Linux-Containern**
```
{
"family" : "taskB",
"memory" : "1024",
"cpu" : "0.5 vCPU",
"proxyConfiguration" : {
"containerName" : "envoy",
"properties" : [
{
"name" : "ProxyIngressPort",
"value" : "15000"
},
{
"name" : "AppPorts",
"value" : "9080"
},
{
"name" : "EgressIgnoredIPs",
"value" : "169.254.170.2,169.254.169.254"
},
{
"name": "EgressIgnoredPorts",
"value": "22"
},
{
"name" : "IgnoredUID",
"value" : "1337"
},
{
"name" : "ProxyEgressPort",
"value" : "15001"
}
],
"type" : "APPMESH"
},
"containerDefinitions" : [
{
"name" : "appName",
"image" : "appImage",
"portMappings" : [
{
"containerPort" : 9080,
"protocol" : "tcp"
}
],
"essential" : true,
"dependsOn" : [
{
"containerName" : "envoy",
"condition" : "HEALTHY"
}
]
},
{
"name" : "envoy",
"image" : "840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod",
"essential" : true,
"environment" : [
{
"name" : "APPMESH_VIRTUAL_NODE_NAME",
"value" : "mesh/apps/virtualNode/serviceB"
}
],
"healthCheck" : {
"command" : [
"CMD-SHELL",
"curl -s http://localhost:9901/server_info | grep state | grep -q LIVE"
],
"interval" : 5,
"retries" : 3,
"startPeriod" : 10,
"timeout" : 2
},
"memory" : 500,
"user" : "1337"
}
],
"requiresCompatibilities" : [ "FARGATE" ],
"taskRoleArn" : "arn:aws:iam::123456789012:role/ecsTaskRole",
"executionRoleArn" : "arn:aws:iam::123456789012:role/ecsTaskExecutionRole",
"networkMode" : "awsvpc"
}
```
**Example JSON für Amazon ECS-Aufgabendefinition mit AWS X-Ray — Fargate auf Linux-Containern**
X-Ray ermöglicht es Ihnen, Daten über Anfragen zu sammeln, die eine Anwendung bedient, und stellt Tools bereit, mit denen Sie den Verkehrsfluss visualisieren können. Durch die Verwendung des X-Ray-Treibers für Envoy kann Envoy Tracing-Informationen an X-Ray melden. Sie können X-Ray Tracing mit der [Envoy-Konfiguration](https://docs.aws.amazon.com/app-mesh/latest/userguide/envoy.html) aktivieren. Je nach Konfiguration sendet Envoy Tracing-Daten an den X-Ray-Daemon, der als [Sidecar-Container](https://docs.aws.amazon.com/xray/latest/devguide/xray-daemon-ecs.html) läuft, und der Daemon leitet die Traces an den X-Ray-Dienst weiter. Sobald die Traces auf X-Ray veröffentlicht wurden, können Sie die X-Ray-Konsole verwenden, um das Diagramm der Serviceanrufe zu visualisieren und Trace-Details anzufordern. Das folgende JSON stellt eine Aufgabendefinition zur Aktivierung der X-Ray-Integration dar.
```
{
"family" : "taskB",
"memory" : "1024",
"cpu" : "512",
"proxyConfiguration" : {
"containerName" : "envoy",
"properties" : [
{
"name" : "ProxyIngressPort",
"value" : "15000"
},
{
"name" : "AppPorts",
"value" : "9080"
},
{
"name" : "EgressIgnoredIPs",
"value" : "169.254.170.2,169.254.169.254"
},
{
"name": "EgressIgnoredPorts",
"value": "22"
},
{
"name" : "IgnoredUID",
"value" : "1337"
},
{
"name" : "ProxyEgressPort",
"value" : "15001"
}
],
"type" : "APPMESH"
},
"containerDefinitions" : [
{
"name" : "appName",
"image" : "appImage",
"portMappings" : [
{
"containerPort" : 9080,
"protocol" : "tcp"
}
],
"essential" : true,
"dependsOn" : [
{
"containerName" : "envoy",
"condition" : "HEALTHY"
}
]
},
{
"name" : "envoy",
"image" : "840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod",
"essential" : true,
"environment" : [
{
"name" : "APPMESH_VIRTUAL_NODE_NAME",
"value" : "mesh/apps/virtualNode/serviceB"
},
{
"name": "ENABLE_ENVOY_XRAY_TRACING",
"value": "1"
}
],
"healthCheck" : {
"command" : [
"CMD-SHELL",
"curl -s http://localhost:9901/server_info | grep state | grep -q LIVE"
],
"interval" : 5,
"retries" : 3,
"startPeriod" : 10,
"timeout" : 2
},
"memory" : 500,
"user" : "1337"
},
{
"name" : "xray-daemon",
"image" : "amazon/aws-xray-daemon",
"user" : "1337",
"essential" : true,
"cpu" : "32",
"memoryReservation" : "256",
"portMappings" : [
{
"containerPort" : 2000,
"protocol" : "udp"
}
]
}
],
"requiresCompatibilities" : [ "FARGATE" ],
"taskRoleArn" : "arn:aws:iam::123456789012:role/ecsTaskRole",
"executionRoleArn" : "arn:aws:iam::123456789012:role/ecsTaskExecutionRole",
"networkMode" : "awsvpc"
}
```
**Example JSON für Amazon ECS-Aufgabendefinition — EC2-Starttyp**
```
{
"family": "taskB",
"memory": "256",
"proxyConfiguration": {
"type": "APPMESH",
"containerName": "envoy",
"properties": [
{
"name": "IgnoredUID",
"value": "1337"
},
{
"name": "ProxyIngressPort",
"value": "15000"
},
{
"name": "ProxyEgressPort",
"value": "15001"
},
{
"name": "AppPorts",
"value": "9080"
},
{
"name": "EgressIgnoredIPs",
"value": "169.254.170.2,169.254.169.254"
},
{
"name": "EgressIgnoredPorts",
"value": "22"
}
]
},
"containerDefinitions": [
{
"name": "appName",
"image": "appImage",
"portMappings": [
{
"containerPort": 9080,
"hostPort": 9080,
"protocol": "tcp"
}
],
"essential": true,
"dependsOn": [
{
"containerName": "envoy",
"condition": "HEALTHY"
}
]
},
{
"name": "envoy",
"image": "840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod",
"essential": true,
"environment": [
{
"name": "APPMESH_VIRTUAL_NODE_NAME",
"value": "mesh/apps/virtualNode/serviceB"
}
],
"healthCheck": {
"command": [
"CMD-SHELL",
"curl -s http://localhost:9901/server_info | grep state | grep -q LIVE"
],
"startPeriod": 10,
"interval": 5,
"timeout": 2,
"retries": 3
},
"user": "1337"
}
],
"requiresCompatibilities" : [ "EC2" ],
"taskRoleArn" : "arn:aws:iam::123456789012:role/ecsTaskRole",
"executionRoleArn" : "arn:aws:iam::123456789012:role/ecsTaskExecutionRole",
"networkMode": "awsvpc"
}
```
**Example JSON für Amazon ECS-Aufgabendefinition mit AWS X-Ray EC2-Starttyp**
```
{
"family": "taskB",
"memory": "256",
"cpu" : "1024",
"proxyConfiguration": {
"type": "APPMESH",
"containerName": "envoy",
"properties": [
{
"name": "IgnoredUID",
"value": "1337"
},
{
"name": "ProxyIngressPort",
"value": "15000"
},
{
"name": "ProxyEgressPort",
"value": "15001"
},
{
"name": "AppPorts",
"value": "9080"
},
{
"name": "EgressIgnoredIPs",
"value": "169.254.170.2,169.254.169.254"
},
{
"name": "EgressIgnoredPorts",
"value": "22"
}
]
},
"containerDefinitions": [
{
"name": "appName",
"image": "appImage",
"portMappings": [
{
"containerPort": 9080,
"hostPort": 9080,
"protocol": "tcp"
}
],
"essential": true,
"dependsOn": [
{
"containerName": "envoy",
"condition": "HEALTHY"
}
]
},
{
"name": "envoy",
"image": "840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod",
"essential": true,
"environment": [
{
"name": "APPMESH_VIRTUAL_NODE_NAME",
"value": "mesh/apps/virtualNode/serviceB"
},
{
"name": "ENABLE_ENVOY_XRAY_TRACING",
"value": "1"
}
],
"healthCheck": {
"command": [
"CMD-SHELL",
"curl -s http://localhost:9901/server_info | grep state | grep -q LIVE"
],
"startPeriod": 10,
"interval": 5,
"timeout": 2,
"retries": 3
},
"user": "1337"
},
{
"name": "xray-daemon",
"image": "amazon/aws-xray-daemon",
"user": "1337",
"essential": true,
"cpu": 32,
"memoryReservation": 256,
"portMappings": [
{
"containerPort": 2000,
"protocol": "udp"
}
]
}
],
"requiresCompatibilities" : [ "EC2" ],
"taskRoleArn" : "arn:aws:iam::123456789012:role/ecsTaskRole",
"executionRoleArn" : "arn:aws:iam::123456789012:role/ecsTaskExecutionRole",
"networkMode": "awsvpc"
}
```
## Fortschrittliche Themen
### Kanarische Bereitstellungen mit App Mesh
Mithilfe von Bereitstellungen und Releases auf Canary können Sie den Datenverkehr zwischen einer alten Version einer Anwendung und einer neu bereitgestellten Version umschalten. Außerdem wird der Zustand der neu bereitgestellten Version überwacht. Falls es Probleme mit der neuen Version gibt, kann das Canary-Deployment den Traffic automatisch wieder auf die alte Version umschalten. Mit Bereitstellungen auf Canary hast du die Möglichkeit, den Datenverkehr zwischen den Anwendungsversionen mit mehr Kontrolle umzuschalten.
Weitere Informationen zur Implementierung von Canary-Bereitstellungen für Amazon ECS mithilfe von App Mesh finden [Sie unter Erstellen einer Pipeline mit Canary-Bereitstellungen für Amazon ECS mithilfe von](https://aws.amazon.com/blogs/containers/create-a-pipeline-with-canary-deployments-for-amazon-ecs-using-aws-app-mesh/) App Mesh
**Anmerkung**
Weitere Beispiele und Komplettlösungen für App Mesh finden Sie im App Mesh [Mesh-Beispiel-Repository](https://github.com/aws/aws-app-mesh-examples).
# Erste Schritte mit AWS App Mesh und Kubernetes
**Wichtig**
Hinweis zum Ende des Supports: Am 30. September 2026 AWS wird der Support für eingestellt. AWS App Mesh Nach dem 30. September 2026 können Sie nicht mehr auf die AWS App Mesh Konsole oder die Ressourcen zugreifen. AWS App Mesh Weitere Informationen finden Sie in diesem Blogbeitrag [Migration von AWS App Mesh zu Amazon ECS Service Connect](https://aws.amazon.com/blogs/containers/migrating-from-aws-app-mesh-to-amazon-ecs-service-connect).
Bei der Integration AWS App Mesh mit Kubernetes mithilfe des App Mesh Mesh-Controllers für Kubernetes verwalten Sie App Mesh Mesh-Ressourcen wie Meshes, virtuelle Dienste, virtuelle Knoten, virtuelle Router und Routen über Kubernetes. Außerdem fügen Sie die App Mesh-Sidecar-Container-Images automatisch zu den Kubernetes-Pod-Spezifikationen hinzu. Dieses Tutorial führt Sie durch die Installation des App Mesh Mesh-Controllers für Kubernetes, um diese Integration zu aktivieren.
Der Controller geht mit der Bereitstellung der folgenden benutzerdefinierten Kubernetes-Ressourcendefinitionen einher: `meshes`, `virtual services`, `virtual nodes` und `virtual routers`. Der Controller überwacht die Erstellung, Änderung und Löschung der benutzerdefinierten Ressourcen und nimmt über die App Mesh-API Änderungen an den entsprechenden App Mesh- [Servicenetze](meshes.md) [Virtuelle Dienste](virtual_services.md) [Virtuelle Knoten](virtual_nodes.md) [Virtuelle Gateways](virtual_gateways.md)[Gateway-Routen](gateway-routes.md),,,, [Virtuelle Router](virtual_routers.md) (einschließlich[Routen](routes.md)) Ressourcen vor. Weitere Informationen oder Beiträge zum Controller finden Sie im [GitHubProjekt](https://github.com/aws/aws-app-mesh-controller-for-k8s).
Der Controller installiert auch einen Webhook, der die folgenden Container in Kubernetes-Pods injiziert, die mit einem von Ihnen angegebenen Namen beschriftet sind.
+ **App Mesh Envoy-Proxy** — Envoy verwendet die in der App Mesh-Steuerebene definierte Konfiguration, um zu bestimmen, wohin Ihr Anwendungsdatenverkehr gesendet werden soll.
+ **App Mesh Proxy Route Manager** — Aktualisiert `iptables` Regeln im Netzwerk-Namespace eines Pods, die eingehenden und ausgehenden Datenverkehr über Envoy weiterleiten. Dieser Container wird als Kubernetes-Init-Container innerhalb des Pods ausgeführt.
## Voraussetzungen
+ Ein vorhandenes Verständnis von App Mesh Mesh-Konzepten. Weitere Informationen finden Sie unter [Was ist AWS App Mesh?](what-is-app-mesh.md).
+ Vorhandene Grundlagen zu Kubernetes-Konzepten. Weitere Informationen finden Sie in der Kubernetes-Dokumentation unter [Was ist Kubernetes](https://kubernetes.io/docs/concepts/overview/what-is-kubernetes/).
+ Ein vorhandener Kubernetes-Cluster. Wenn Sie noch keinen Cluster haben, finden Sie weitere Informationen unter [Erste Schritte mit Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/getting-started.html) im *Amazon EKS-Benutzerhandbuch*. Wenn Sie Ihren eigenen Kubernetes-Cluster auf Amazon EC2 ausführen, stellen Sie sicher, dass Docker gegenüber dem Amazon ECR-Repository authentifiziert ist, in dem sich das Envoy-Image befindet. Weitere Informationen finden Sie unter [Envoy-Image](https://docs.aws.amazon.com/app-mesh/latest/userguide/envoy.html), [Registry-Authentifizierung](https://docs.aws.amazon.com/AmazonECR/latest/userguide/Registries.html#registry_auth) im Amazon Elastic Container Registry-Benutzerhandbuch und [Pull an Image from a Private Registry](https://kubernetes.io/docs/tasks/configure-pod-container/pull-image-private-registry/) in der Kubernetes-Dokumentation.
+ App Mesh unterstützt Linux-Dienste, die mit DNS oder beidem registriert sind. AWS Cloud Map Um dieses Handbuch für Erste Schritte zu verwenden, empfehlen wir, dass Sie über drei vorhandene Services verfügen, die bei DNS registriert sind. Bei den Verfahren in diesem Thema wird davon ausgegangen `serviceA``serviceB`, dass die vorhandenen Dienste benannt sind `serviceBv2` und dass alle Dienste über einen Namespace namens auffindbar sind. `apps.local`
Sie können ein Service-Mesh und seine Ressourcen erstellen, auch wenn die Services nicht vorhanden sind. Sie können das Mesh jedoch erst verwenden, wenn Sie tatsächliche Services bereitgestellt haben.
+ Die AWS CLI Version 1.18.116 oder höher oder 2.0.38 oder höher ist installiert. [Informationen zur Installation oder zum Upgrade von finden Sie unter Installation von. AWS CLIAWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html)
+ Einen `kubectl`-Client, der für die Kommunikation mit Ihrem Kubernetes-Cluster konfiguriert ist. Wenn Sie Amazon Elastic Kubernetes Service verwenden, können Sie die Anweisungen zur Installation `[kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html)` und Konfiguration einer `[kubeconfig](https://docs.aws.amazon.com/eks/latest/userguide/create-kubeconfig.html)` Datei verwenden.
+ Helm Version 3.0 oder höher ist installiert. Wenn Sie Helm nicht installiert haben, finden Sie weitere Informationen [unter Using Helm with Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/helm.html) im *Amazon EKS-Benutzerhandbuch*.
+ Amazon EKS unterstützt `IPv4_ONLY` derzeit `IPv6_ONLY` nur IP-Einstellungen, da Amazon EKS derzeit nur Pods unterstützt, die entweder nur `IPv4` Traffic oder nur `IPv6` Traffic bereitstellen können.
Die verbleibenden Schritte gehen davon aus, dass die tatsächlichen Services als `serviceA`, `serviceB` und `serviceBv2` benannt sind, und dass alle Services über einen Namespace mit dem Namen `apps.local` gefunden werden können.
## Schritt 1: Installieren der Integrationskomponenten
Installieren Sie die Integrationskomponenten einmal auf jedem Cluster, der Pods hostet, die Sie mit App Mesh verwenden möchten.
**So installieren Sie die Integrationskomponenten**
1. Für die verbleibenden Schritte dieses Verfahrens ist ein Cluster erforderlich, ohne dass eine Vorabversion des Controllers installiert ist. Wenn Sie eine Vorabversion installiert haben oder sich nicht sicher sind, ob Sie eine installiert haben, können Sie ein Skript herunterladen und ausführen, das überprüft, ob eine Vorabversion auf Ihrem Cluster installiert ist.
```
curl -o pre_upgrade_check.sh https://raw.githubusercontent.com/aws/eks-charts/master/stable/appmesh-controller/upgrade/pre_upgrade_check.sh
sh ./pre_upgrade_check.sh
```
Wenn das Skript `Your cluster is ready for upgrade. Please proceed to the installation instructions` zurückgibt, können Sie mit dem nächsten Schritt fortfahren. Wenn eine andere Meldung zurückgegeben wird, müssen Sie die Upgrade-Schritte ausführen, bevor Sie fortfahren. [Weitere Informationen zum Upgrade einer Vorabversion finden Sie unter Upgrade auf.](https://github.com/aws/eks-charts/blob/master/stable/appmesh-controller/README.md#upgrade) GitHub
1. Fügen Sie das `eks-charts`-Repository Helm hinzu.
```
helm repo add eks https://aws.github.io/eks-charts
```
1. Installieren Sie die benutzerdefinierte Ressourcendefinitionen (CRD) von App Mesh Kubernetes.
```
kubectl apply -k "https://github.com/aws/eks-charts/stable/appmesh-controller/crds?ref=master"
```
1. Erstellen Sie einen Kubernetes-Namespace für den Controller.
```
kubectl create ns appmesh-system
```
1. Legen Sie die folgenden Variablen für die Verwendung in späteren Schritten fest. Ersetzen Sie `cluster-name` und `Region-code` durch die Werte für Ihren vorhandenen Cluster.
```
export CLUSTER_NAME=cluster-name
export AWS_REGION=Region-code
```
1. (Optional) Wenn Sie den Controller auf Fargate ausführen möchten, müssen Sie ein Fargate-Profil erstellen. Falls Sie es noch nicht `eksctl` installiert haben, finden Sie [weitere Informationen unter Installation oder Upgrade `eksctl`](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html#installing-eksctl) im *Amazon EKS-Benutzerhandbuch*. Wenn Sie das Profil lieber mit der Konsole erstellen möchten, finden Sie weitere Informationen unter [Erstellen eines Fargate-Profils](https://docs.aws.amazon.com/eks/latest/userguide/fargate-profile.html#create-fargate-profile) im *Amazon EKS-Benutzerhandbuch*.
```
eksctl create fargateprofile --cluster $CLUSTER_NAME --name appmesh-system --namespace appmesh-system
```
1. Erstellen Sie einen OpenID Connect (OIDC)-Identitätsanbieter für Ihren Cluster. Wenn Sie es noch nicht `eksctl` installiert haben, können Sie es mithilfe der Anweisungen unter [Installation oder Upgrade `eksctl`](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html#installing-eksctl) im *Amazon EKS-Benutzerhandbuch* installieren. Wenn Sie den Anbieter lieber über die Konsole erstellen möchten, finden Sie weitere Informationen unter [Aktivieren von IAM-Rollen für Dienstkonten auf Ihrem Cluster](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html) im *Amazon EKS-Benutzerhandbuch*.
```
eksctl utils associate-iam-oidc-provider \
--region=$AWS_REGION \
--cluster $CLUSTER_NAME \
--approve
```
1. Erstellen Sie eine IAM-Rolle, fügen Sie ihr die [https://console.aws.amazon.com/iam/home?#policies/arn:aws:iam::aws:policy/AWSAppMeshFullAccess$jsonEditor](https://console.aws.amazon.com/iam/home?#policies/arn:aws:iam::aws:policy/AWSAppMeshFullAccess$jsonEditor)und die [https://console.aws.amazon.com/iam/home?#policies/arn:aws:iam::aws:policy/AWSCloudMapFullAccess$jsonEditor](https://console.aws.amazon.com/iam/home?#policies/arn:aws:iam::aws:policy/AWSCloudMapFullAccess$jsonEditor) AWS verwalteten Richtlinien hinzu und binden Sie sie an das `appmesh-controller` Kubernetes-Servicekonto. Die Rolle ermöglicht es dem Controller, App Mesh-Ressourcen hinzuzufügen, zu entfernen und zu ändern.
**Anmerkung**
Der Befehl erstellt eine AWS IAM-Rolle mit einem automatisch generierten Namen. Sie können den erstellten IAM-Rollennamen nicht angeben.
```
eksctl create iamserviceaccount \
--cluster $CLUSTER_NAME \
--namespace appmesh-system \
--name appmesh-controller \
--attach-policy-arn arn:aws:iam::aws:policy/AWSCloudMapFullAccess,arn:aws:iam::aws:policy/AWSAppMeshFullAccess \
--override-existing-serviceaccounts \
--approve
```
Wenn Sie das Servicekonto lieber mit dem AWS-Managementkonsole oder erstellen möchten AWS CLI, finden Sie weitere Informationen unter [Erstellen einer IAM-Rolle und -Richtlinie für Ihr Servicekonto](https://docs.aws.amazon.com/eks/latest/userguide/create-service-account-iam-policy-and-role.html#create-service-account-iam-role) im *Amazon EKS-Benutzerhandbuch*. Wenn Sie das AWS-Managementkonsole oder verwenden, AWS CLI um das Konto zu erstellen, müssen Sie die Rolle auch einem Kubernetes-Servicekonto zuordnen. Weitere Informationen finden Sie unter [Angeben einer IAM-Rolle für Ihr Servicekonto](https://docs.aws.amazon.com/eks/latest/userguide/specify-service-account-role.html) im *Amazon EKS-Benutzerhandbuch*.
1.
**Stellen Sie den App Mesh Mesh-Controller bereit. Eine Liste aller Konfigurationsoptionen finden Sie unter [Konfiguration](https://github.com/aws/eks-charts/blob/master/stable/appmesh-controller/README.md#configuration) unter GitHub.**
1. Um den App Mesh-Controller für einen privaten Cluster bereitzustellen, müssen Sie zuerst App Mesh und Service Discovery Amazon VPC-Endpoints für das verknüpfte private Subnetz aktivieren. Sie müssen auch die festlegen. `accountId`
```
--set accountId=$AWS_ACCOUNT_ID
```
Um X-Ray Tracing in einem privaten Cluster zu aktivieren, aktivieren Sie die Amazon VPC-Endpoints X-Ray und Amazon ECR. Der Controller verwendet `public.ecr.aws/xray/aws-xray-daemon:latest` standardmäßig. Ziehen Sie dieses Bild also lokal und [übertragen Sie es in Ihr persönliches ECR-Repository](https://docs.aws.amazon.com/AmazonECR/latest/userguide/docker-push-ecr-image.html).
**Anmerkung**
[Amazon VPC-Endpunkte](https://docs.aws.amazon.com/AmazonECR/latest/userguide/vpc-endpoints.html) unterstützen derzeit keine öffentlichen Amazon ECR-Repositorys.
Das folgende Beispiel zeigt die Bereitstellung des Controllers mit Konfigurationen für X-Ray.
```
helm upgrade -i appmesh-controller eks/appmesh-controller \
--namespace appmesh-system \
--set region=$AWS_REGION \
--set serviceAccount.create=false \
--set serviceAccount.name=appmesh-controller \
--set accountId=$AWS_ACCOUNT_ID \
--set log.level=debug \
--set tracing.enabled=true \
--set tracing.provider=x-ray \
--set xray.image.repository=your-account-id.dkr.ecr.your-region.amazonaws.com/your-repository \
--set xray.image.tag=your-xray-daemon-image-tag
```
Überprüfen Sie, ob der X-Ray-Daemon erfolgreich injiziert wurde, wenn Sie die Anwendungsbereitstellung mit Ihrem virtuellen Knoten oder Gateway verbinden.
Weitere Informationen finden Sie unter [Private Clusters](https://docs.aws.amazon.com/eks/latest/userguide/private-clusters.html) im *Amazon EKS-Benutzerhandbuch*.
1. Stellen Sie den App Mesh Mesh-Controller für andere Cluster bereit. Eine Liste aller Konfigurationsoptionen finden Sie unter [Konfiguration](https://github.com/aws/eks-charts/blob/master/stable/appmesh-controller/README.md#configuration) unter GitHub.
```
helm upgrade -i appmesh-controller eks/appmesh-controller \
--namespace appmesh-system \
--set region=$AWS_REGION \
--set serviceAccount.create=false \
--set serviceAccount.name=appmesh-controller
```
**Anmerkung**
Wenn es sich bei Ihrer Amazon EKS-Cluster-Familie um eine handelt`IPv6`, legen Sie bei der Bereitstellung des App Mesh Mesh-Controllers den Cluster-Namen fest, indem Sie dem vorherigen Befehl die folgende Option hinzufügen`--set clusterName=$CLUSTER_NAME`.
**Wichtig**
Wenn sich Ihr Cluster in den `af-south-1` Regionen `me-south-1` `ap-east-1``ap-southeast-3`,`eu-south-1`,`il-central-1`,, oder befindet, müssen Sie dem vorherigen Befehl die folgende Option hinzufügen:
Ersetzen Sie *account-id* und *Region-code* durch einen der entsprechenden Wertesätze.
```
--set image.repository=account-id.dkr.ecr.Region-code.amazonaws.com/amazon/appmesh-controller
```
772975370895.dkr. ecr.me-south-1.amazonaws.com /:v1.34.13.0-prod aws-appmesh-envoy
856666278305.dkr. ecr.ap-east-1.amazonaws.com /:v1.34.13.0-prod aws-appmesh-envoy
909464085924.dkr. ecr.ap-southeast-3.amazonaws.com /:v1.34.13.0-prod aws-appmesh-envoy
422531588944.dkr. ecr.eu-south-1.amazonaws.com /:v1.34.13.0-prod aws-appmesh-envoy
564877687649.dkr. ecr.il-central-1.amazonaws.com /:v1.34.13.0-prod aws-appmesh-envoy
924023996002.dkr. ecr.af-south-1.amazonaws.com /:v1.34.13.0-prod aws-appmesh-envoy
[Das ältere Bild finden Sie im URIs Change Log On.](https://github.com/aws/aws-app-mesh-controller-for-k8s/releases) GitHub Die Version der AWS Konten, auf denen die Bilder vorhanden sind, hat sich geändert`v1.5.0`. Ältere Versionen der Images werden auf AWS Konten gehostet, die sich in den Amazon Elastic Kubernetes Service [Amazon-Container-Image-Registern](https://docs.aws.amazon.com/eks/latest/userguide/add-ons-images.html) befinden.
```
--set sidecar.image.repository=account-id.dkr.ecr.Region-code.amazonaws.com/aws-appmesh-envoy
```
772975370895.dkr.ecr.me-south-1.amazonaws. com/amazon/appmesh-Controller: v1.13.1
856666278305.dkr.ecr.ap-east-1.amazonaws. com/amazon/appmesh-Controller: v1.13.1
909464085924.dkr.ecr.ap-southeast-3.amazonaws. com/amazon/appmesh-Controller: v1.13.1
422531588944.dkr.ecr.eu-south-1.amazonaws. com/amazon/appmesh-Controller: v1.13.1
564877687649.dkr.ecr.il-central-1.amazonaws. com/amazon/appmesh-Controller: v1.13.1
924023996002.dkr.ecr.af-south-1.amazonaws. com/amazon/appmesh-Controller: v1.13.1
```
--set sidecar.image.repository=account-id.dkr.ecr.Region-code.amazonaws.com/aws-appmesh-envoy
```
772975370895.dkr. ecr.me-south-1.amazonaws.com/-manager:v7-prod aws-appmesh-proxy-route
856666278305.dkr. ecr.ap-east-1.amazonaws.com/aws-appmesh-proxy-route-manager:v7-prod
909464085924.dkr. ecr.ap-southeast-3.amazonaws.com/-manager:v7-prod aws-appmesh-proxy-route
422531588944.dkr. ecr.eu-south-1.amazonaws.com/-manager:v7-prod aws-appmesh-proxy-route
564877687649.dkr. ecr.il-central-1.amazonaws.com/aws-appmesh-proxy-route-manager:v7-prod
924023996002.dkr. ecr.af-south-1.amazonaws.com/-manager:v7-prod aws-appmesh-proxy-route
**Wichtig**
Nur Version v1.9.0.0-prod oder höher wird für die Verwendung mit App Mesh unterstützt.
1. Vergewissern Sie sich, dass die Controller-Version `v1.4.0` oder höher ist. [Sie können das Änderungsprotokoll überprüfen.](https://github.com/aws/aws-app-mesh-controller-for-k8s/releases) GitHub
```
kubectl get deployment appmesh-controller \
-n appmesh-system \
-o json | jq -r ".spec.template.spec.containers[].image" | cut -f2 -d ':'
```
**Anmerkung**
Wenn Sie das Protokoll für den laufenden Container anzeigen, wird möglicherweise eine Zeile angezeigt, die den folgenden Text enthält. Dies kann gefahrlos ignoriert werden kann.
```
Neither -kubeconfig nor -master was specified. Using the inClusterConfig. This might not work.
```
## Schritt 2: App Mesh Mesh-Ressourcen bereitstellen
Wenn Sie eine Anwendung in Kubernetes bereitstellen, erstellen Sie auch die benutzerdefinierten Kubernetes-Ressourcen, sodass der Controller die entsprechenden App Mesh Mesh-Ressourcen erstellen kann. Das folgende Verfahren hilft Ihnen bei der Bereitstellung von App Mesh Mesh-Ressourcen mit einigen ihrer Funktionen. Beispielmanifeste für die Bereitstellung anderer App Mesh-Ressourcenfunktionen finden Sie in den `v1beta2` Unterordnern vieler Feature-Ordner, die unter [App Mesh Walkthroughs](https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs) on aufgeführt sind. GitHub
**Wichtig**
Sobald der Controller eine App Mesh Mesh-Ressource erstellt hat, empfehlen wir, dass Sie die App Mesh Mesh-Ressource nur mit dem Controller ändern oder löschen. Wenn Sie mit App Mesh Änderungen an der Ressource vornehmen oder sie löschen, ändert der Controller die geänderte oder gelöschte App Mesh Mesh-Ressource standardmäßig zehn Stunden lang nicht und erstellt sie nicht neu. Sie können diese Dauer so konfigurieren, dass sie geringer ist. Weitere Informationen finden Sie unter [Konfiguration von](https://github.com/aws/eks-charts/blob/master/stable/appmesh-controller/README.md#configuration). GitHub
**So stellen Sie App-Mesh-Ressourcen bereit**
1. Erstellen Sie einen Kubernetes-Namespace, in dem App Mesh Mesh-Ressourcen bereitgestellt werden sollen.
1. Speichern Sie den folgenden Inhalt in einer Datei mit dem Namen `namespace.yaml` auf Ihrem Computer.
```
apiVersion: v1
kind: Namespace
metadata:
name: my-apps
labels:
mesh: my-mesh
appmesh.k8s.aws/sidecarInjectorWebhook: enabled
```
1. Erstellen Sie den Namespace.
```
kubectl apply -f namespace.yaml
```
1. Erstellen Sie ein App Mesh Service Mesh.
1. Speichern Sie den folgenden Inhalt in einer Datei mit dem Namen `mesh.yaml` auf Ihrem Computer. Die Datei wird verwendet, um eine Mesh-Ressource mit dem Namen zu erstellen`my-mesh`. Ein Service Mesh ist eine logische Begrenzung für den Netzwerkdatenverkehr zwischen den darin vorhandenen Services.
```
apiVersion: appmesh.k8s.aws/v1beta2
kind: Mesh
metadata:
name: my-mesh
spec:
namespaceSelector:
matchLabels:
mesh: my-mesh
```
1. Erzeugen Sie das Mesh.
```
kubectl apply -f mesh.yaml
```
1. Zeigen Sie die Details der erstellten Kubernetes-Mesh-Ressource an.
```
kubectl describe mesh my-mesh
```
Ausgabe
```
Name: my-mesh
Namespace:
Labels:
Annotations: kubectl.kubernetes.io/last-applied-configuration:
{"apiVersion":"appmesh.k8s.aws/v1beta2","kind":"Mesh","metadata":{"annotations":{},"name":"my-mesh"},"spec":{"namespaceSelector":{"matchLa...
API Version: appmesh.k8s.aws/v1beta2
Kind: Mesh
Metadata:
Creation Timestamp: 2020-06-17T14:51:37Z
Finalizers:
finalizers.appmesh.k8s.aws/mesh-members
finalizers.appmesh.k8s.aws/aws-appmesh-resources
Generation: 1
Resource Version: 6295
Self Link: /apis/appmesh.k8s.aws/v1beta2/meshes/my-mesh
UID: 111a11b1-c11d-1e1f-gh1i-j11k1l111m711
Spec:
Aws Name: my-mesh
Namespace Selector:
Match Labels:
Mesh: my-mesh
Status:
Conditions:
Last Transition Time: 2020-06-17T14:51:37Z
Status: True
Type: MeshActive
Mesh ARN: arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh
Observed Generation: 1
Events:
```
1. Sehen Sie sich die Details zum App Mesh Service Mesh an, das der Controller erstellt hat.
```
aws appmesh describe-mesh --mesh-name my-mesh
```
Ausgabe
```
{
"mesh": {
"meshName": "my-mesh",
"metadata": {
"arn": "arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh",
"createdAt": "2020-06-17T09:51:37.920000-05:00",
"lastUpdatedAt": "2020-06-17T09:51:37.920000-05:00",
"meshOwner": "111122223333",
"resourceOwner": "111122223333",
"uid": "111a11b1-c11d-1e1f-gh1i-j11k1l111m711",
"version": 1
},
"spec": {},
"status": {
"status": "ACTIVE"
}
}
}
```
1. Erstellen Sie einen virtuellen App-Mesh-Knoten. Ein virtueller Knoten fungiert als logischer Zeiger auf eine Kubernetes-Bereitstellung.
1. Speichern Sie den folgenden Inhalt in einer Datei mit dem Namen `virtual-node.yaml` auf Ihrem Computer. Die Datei wird verwendet, um einen virtuellen App Mesh-Knoten zu erstellen, der `my-service-a` im *`my-apps`* Namespace benannt ist. Der virtuelle Knoten stellt einen Kubernetes-Service dar, der in einem späteren Schritt erstellt wird. Der Wert für `hostname` ist der vollqualifizierte DNS-Hostname des eigentlichen Services, den dieser virtuelle Knoten darstellt.
```
apiVersion: appmesh.k8s.aws/v1beta2
kind: VirtualNode
metadata:
name: my-service-a
namespace: my-apps
spec:
podSelector:
matchLabels:
app: my-app-1
listeners:
- portMapping:
port: 80
protocol: http
serviceDiscovery:
dns:
hostname: my-service-a.my-apps.svc.cluster.local
```
Virtuelle Knoten verfügen über Funktionen wie end-to-end Verschlüsselung und Integritätsprüfungen, die in diesem Tutorial nicht behandelt werden. Weitere Informationen finden Sie unter [Virtuelle Knoten](virtual_nodes.md). Führen Sie den folgenden Befehl aus, um alle verfügbaren Einstellungen für einen virtuellen Knoten anzuzeigen, die Sie in der vorherigen Spezifikation festlegen können.
```
aws appmesh create-virtual-node --generate-cli-skeleton yaml-input
```
1. Stellen Sie den virtuellen Knoten bereit.
```
kubectl apply -f virtual-node.yaml
```
1. Zeigen Sie die Details der erstellten virtuellen Knotenressource von Kubernetes an.
```
kubectl describe virtualnode my-service-a -n my-apps
```
Ausgabe
```
Name: my-service-a
Namespace: my-apps
Labels:
Annotations: kubectl.kubernetes.io/last-applied-configuration:
{"apiVersion":"appmesh.k8s.aws/v1beta2","kind":"VirtualNode","metadata":{"annotations":{},"name":"my-service-a","namespace":"my-apps"},"s...
API Version: appmesh.k8s.aws/v1beta2
Kind: VirtualNode
Metadata:
Creation Timestamp: 2020-06-17T14:57:29Z
Finalizers:
finalizers.appmesh.k8s.aws/aws-appmesh-resources
Generation: 2
Resource Version: 22545
Self Link: /apis/appmesh.k8s.aws/v1beta2/namespaces/my-apps/virtualnodes/my-service-a
UID: 111a11b1-c11d-1e1f-gh1i-j11k1l111m711
Spec:
Aws Name: my-service-a_my-apps
Listeners:
Port Mapping:
Port: 80
Protocol: http
Mesh Ref:
Name: my-mesh
UID: 111a11b1-c11d-1e1f-gh1i-j11k1l111m711
Pod Selector:
Match Labels:
App: nginx
Service Discovery:
Dns:
Hostname: my-service-a.my-apps.svc.cluster.local
Status:
Conditions:
Last Transition Time: 2020-06-17T14:57:29Z
Status: True
Type: VirtualNodeActive
Observed Generation: 2
Virtual Node ARN: arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualNode/my-service-a_my-apps
Events:
```
1. Zeigen Sie die Details des virtuellen Knotens an, den der Controller in App Mesh erstellt hat.
**Anmerkung**
Obwohl der Name des in Kubernetes erstellten virtuellen Knotens `my-service-a` lautet, hat der in App Mesh erstellte virtuelle Knoten den Namen `my-service-a_my-apps`. Der Controller hängt den Kubernetes-Namespace-Namen an den Namen des virtuellen App Mesh-Knotens an, wenn er die App Mesh Mesh-Ressource erstellt. Der Namespace-Name wird hinzugefügt, weil Sie in Kubernetes virtuelle Knoten mit demselben Namen in verschiedenen Namespaces erstellen können, aber in App Mesh muss ein virtueller Knotenname innerhalb eines Meshs eindeutig sein.
```
aws appmesh describe-virtual-node --mesh-name my-mesh --virtual-node-name my-service-a_my-apps
```
Ausgabe
```
{
"virtualNode": {
"meshName": "my-mesh",
"metadata": {
"arn": "arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualNode/my-service-a_my-apps",
"createdAt": "2020-06-17T09:57:29.840000-05:00",
"lastUpdatedAt": "2020-06-17T09:57:29.840000-05:00",
"meshOwner": "111122223333",
"resourceOwner": "111122223333",
"uid": "111a11b1-c11d-1e1f-gh1i-j11k1l111m711",
"version": 1
},
"spec": {
"backends": [],
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http"
}
}
],
"serviceDiscovery": {
"dns": {
"hostname": "my-service-a.my-apps.svc.cluster.local"
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualNodeName": "my-service-a_my-apps"
}
}
```
1. Erstellen Sie einen virtuellen App Mesh Mesh-Router. Virtuelle Router verarbeiten den Datenverkehr für einen oder mehrere virtuelle Services innerhalb Ihres Gitters.
1. Speichern Sie den folgenden Inhalt in einer Datei mit dem Namen `virtual-router.yaml` auf Ihrem Computer. Die Datei wird verwendet, um einen virtuellen Router zu erstellen, der den Datenverkehr an den virtuellen Knoten `my-service-a` weiterleitet, der im vorherigen Schritt erstellt wurde. Der Controller erstellt den virtuellen App Mesh Mesh-Router und leitet Ressourcen weiter. Sie können viele weitere Funktionen für Ihre Routen angeben und andere Protokolle als `http` verwenden. Weitere Informationen erhalten Sie unter [Virtuelle Router](virtual_routers.md) und [Routen](routes.md). Beachten Sie, dass der Name des virtuellen Knotens, auf den verwiesen wird, der Name des virtuellen Kubernetes-Knotens ist, nicht der Name des virtuellen App Mesh-Knotens, der vom Controller in App Mesh erstellt wurde.
```
apiVersion: appmesh.k8s.aws/v1beta2
kind: VirtualRouter
metadata:
namespace: my-apps
name: my-service-a-virtual-router
spec:
listeners:
- portMapping:
port: 80
protocol: http
routes:
- name: my-service-a-route
httpRoute:
match:
prefix: /
action:
weightedTargets:
- virtualNodeRef:
name: my-service-a
weight: 1
```
(Optional) Führen Sie den folgenden Befehl aus, um alle verfügbaren Einstellungen für einen virtuellen Router anzuzeigen, die Sie in der vorherigen Spezifikation festlegen können.
```
aws appmesh create-virtual-router --generate-cli-skeleton yaml-input
```
Führen Sie den folgenden Befehl aus, um alle verfügbaren Einstellungen für eine Route anzuzeigen, die Sie in der vorherigen Spezifikation festlegen können.
```
aws appmesh create-route --generate-cli-skeleton yaml-input
```
1. Stellen Sie den virtuellen Router bereit.
```
kubectl apply -f virtual-router.yaml
```
1. Zeigen Sie die virtuelle Routerressource von Kubernetes an, die erstellt wurde.
```
kubectl describe virtualrouter my-service-a-virtual-router -n my-apps
```
Gekürzte Ausgabe
```
Name: my-service-a-virtual-router
Namespace: my-apps
Labels:
Annotations: kubectl.kubernetes.io/last-applied-configuration:
{"apiVersion":"appmesh.k8s.aws/v1beta2","kind":"VirtualRouter","metadata":{"annotations":{},"name":"my-service-a-virtual-router","namespac...
API Version: appmesh.k8s.aws/v1beta2
Kind: VirtualRouter
...
Spec:
Aws Name: my-service-a-virtual-router_my-apps
Listeners:
Port Mapping:
Port: 80
Protocol: http
Mesh Ref:
Name: my-mesh
UID: 111a11b1-c11d-1e1f-gh1i-j11k1l111m711
Routes:
Http Route:
Action:
Weighted Targets:
Virtual Node Ref:
Name: my-service-a
Weight: 1
Match:
Prefix: /
Name: my-service-a-route
Status:
Conditions:
Last Transition Time: 2020-06-17T15:14:01Z
Status: True
Type: VirtualRouterActive
Observed Generation: 1
Route AR Ns:
My - Service - A - Route: arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualRouter/my-service-a-virtual-router_my-apps/route/my-service-a-route
Virtual Router ARN: arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualRouter/my-service-a-virtual-router_my-apps
Events:
```
1. Zeigen Sie die virtuelle Router-Ressource an, die der Controller in App Mesh erstellt hat. Sie geben `my-service-a-virtual-router_my-apps` für an`name`, weil der Controller, als er den virtuellen Router in App Mesh erstellt hat, den Kubernetes-Namespace-Namen an den Namen des virtuellen Routers angehängt hat.
```
aws appmesh describe-virtual-router --virtual-router-name my-service-a-virtual-router_my-apps --mesh-name my-mesh
```
Ausgabe
```
{
"virtualRouter": {
"meshName": "my-mesh",
"metadata": {
"arn": "arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualRouter/my-service-a-virtual-router_my-apps",
"createdAt": "2020-06-17T10:14:01.547000-05:00",
"lastUpdatedAt": "2020-06-17T10:14:01.547000-05:00",
"meshOwner": "111122223333",
"resourceOwner": "111122223333",
"uid": "111a11b1-c11d-1e1f-gh1i-j11k1l111m711",
"version": 1
},
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http"
}
}
]
},
"status": {
"status": "ACTIVE"
},
"virtualRouterName": "my-service-a-virtual-router_my-apps"
}
}
```
1. Zeigen Sie die Routenressource an, die der Controller in App Mesh erstellt hat. Eine Routenressource wurde in Kubernetes nicht erstellt, da die Route Teil der Konfiguration des virtuellen Routers in Kubernetes ist. Die Routeninformationen wurden in den Kubernetes-Ressourcendetails im Teilschritt `c` angezeigt. Der Controller hat den Kubernetes-Namespace-Namen nicht an den App Mesh-Routennamen angehängt, als er die Route in App Mesh erstellt hat, da Routennamen für einen virtuellen Router eindeutig sind.
```
aws appmesh describe-route \
--route-name my-service-a-route \
--virtual-router-name my-service-a-virtual-router_my-apps \
--mesh-name my-mesh
```
Ausgabe
```
{
"route": {
"meshName": "my-mesh",
"metadata": {
"arn": "arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualRouter/my-service-a-virtual-router_my-apps/route/my-service-a-route",
"createdAt": "2020-06-17T10:14:01.577000-05:00",
"lastUpdatedAt": "2020-06-17T10:14:01.577000-05:00",
"meshOwner": "111122223333",
"resourceOwner": "111122223333",
"uid": "111a11b1-c11d-1e1f-gh1i-j11k1l111m711",
"version": 1
},
"routeName": "my-service-a-route",
"spec": {
"httpRoute": {
"action": {
"weightedTargets": [
{
"virtualNode": "my-service-a_my-apps",
"weight": 1
}
]
},
"match": {
"prefix": "/"
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualRouterName": "my-service-a-virtual-router_my-apps"
}
}
```
1. Erstellen Sie einen virtuellen App Mesh Mesh-Dienst. Bei einem virtuellen Service handelt es sich um eine Abstraktion eines echten Service, der von einem virtuellen Knoten direkt oder indirekt mittels eines virtuellen Routers bereitgestellt wird. Abhängige Services rufen Ihren virtuellen Service über den Namen auf. Obwohl der Name für App Mesh keine Rolle spielt, empfehlen wir, dem virtuellen Dienst den vollqualifizierten Domainnamen des tatsächlichen Dienstes zu geben, den der virtuelle Dienst darstellt. Wenn Sie Ihre virtuellen Services auf diese Weise benennen, müssen Sie Ihren Anwendungscode nicht ändern, um auf einen anderen Namen zu verweisen. Die Anforderungen werden an den virtuellen Knoten oder virtuellen Router weitergeleitet, der als Anbieter für den virtuellen Service angegeben ist.
1. Speichern Sie den folgenden Inhalt in einer Datei mit dem Namen `virtual-service.yaml` auf Ihrem Computer. Die Datei wird verwendet, um einen virtuellen Dienst zu erstellen, der einen virtuellen Router-Anbieter verwendet, um den Datenverkehr an den virtuellen Knoten weiterzuleiten`my-service-a`, der in einem vorherigen Schritt erstellt wurde. Der Wert für `awsName` in der `spec` ist der vollqualifizierte Domänenname (FQDN) des tatsächlichen Kubernetes-Services, den dieser virtuelle Service abstrahiert. Der Kubernetes-Service wird in [Schritt 3: Erstellen oder Aktualisieren von Services](#create-update-services) erstellt. Weitere Informationen finden Sie unter [Virtuelle Dienste](virtual_services.md).
```
apiVersion: appmesh.k8s.aws/v1beta2
kind: VirtualService
metadata:
name: my-service-a
namespace: my-apps
spec:
awsName: my-service-a.my-apps.svc.cluster.local
provider:
virtualRouter:
virtualRouterRef:
name: my-service-a-virtual-router
```
Führen Sie den folgenden Befehl aus, um alle verfügbaren Einstellungen für einen virtuellen Service anzuzeigen, die Sie in der vorherigen Spezifikation festlegen können.
```
aws appmesh create-virtual-service --generate-cli-skeleton yaml-input
```
1. Erstellen Sie den virtuellen Service.
```
kubectl apply -f virtual-service.yaml
```
1. Zeigen Sie die Details der virtuellen Serviceressource von Kubernetes an, die erstellt wurde.
```
kubectl describe virtualservice my-service-a -n my-apps
```
Ausgabe
```
Name: my-service-a
Namespace: my-apps
Labels:
Annotations: kubectl.kubernetes.io/last-applied-configuration:
{"apiVersion":"appmesh.k8s.aws/v1beta2","kind":"VirtualService","metadata":{"annotations":{},"name":"my-service-a","namespace":"my-apps"}...
API Version: appmesh.k8s.aws/v1beta2
Kind: VirtualService
Metadata:
Creation Timestamp: 2020-06-17T15:48:40Z
Finalizers:
finalizers.appmesh.k8s.aws/aws-appmesh-resources
Generation: 1
Resource Version: 13598
Self Link: /apis/appmesh.k8s.aws/v1beta2/namespaces/my-apps/virtualservices/my-service-a
UID: 111a11b1-c11d-1e1f-gh1i-j11k1l111m711
Spec:
Aws Name: my-service-a.my-apps.svc.cluster.local
Mesh Ref:
Name: my-mesh
UID: 111a11b1-c11d-1e1f-gh1i-j11k1l111m711
Provider:
Virtual Router:
Virtual Router Ref:
Name: my-service-a-virtual-router
Status:
Conditions:
Last Transition Time: 2020-06-17T15:48:40Z
Status: True
Type: VirtualServiceActive
Observed Generation: 1
Virtual Service ARN: arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualService/my-service-a.my-apps.svc.cluster.local
Events:
```
1. Zeigen Sie die Details der virtuellen Dienstressource an, die der Controller in App Mesh erstellt hat. Der Kubernetes-Controller hat den Kubernetes-Namespace-Namen nicht an den Namen des virtuellen App Mesh-Dienstes angehängt, als er den virtuellen Dienst in App Mesh erstellt hat, da der Name des virtuellen Dienstes ein eindeutiger FQDN ist.
```
aws appmesh describe-virtual-service --virtual-service-name my-service-a.my-apps.svc.cluster.local --mesh-name my-mesh
```
Ausgabe
```
{
"virtualService": {
"meshName": "my-mesh",
"metadata": {
"arn": "arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualService/my-service-a.my-apps.svc.cluster.local",
"createdAt": "2020-06-17T10:48:40.182000-05:00",
"lastUpdatedAt": "2020-06-17T10:48:40.182000-05:00",
"meshOwner": "111122223333",
"resourceOwner": "111122223333",
"uid": "111a11b1-c11d-1e1f-gh1i-j11k1l111m711",
"version": 1
},
"spec": {
"provider": {
"virtualRouter": {
"virtualRouterName": "my-service-a-virtual-router_my-apps"
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualServiceName": "my-service-a.my-apps.svc.cluster.local"
}
}
```
Obwohl in diesem Tutorial nicht behandelt, kann der Controller auch App Mesh [Virtuelle Gateways](virtual_gateways.md) und bereitstellen[Gateway-Routen](gateway-routes.md). Eine exemplarische Vorgehensweise zur Bereitstellung dieser Ressourcen mit dem Controller finden Sie unter [Konfiguration des Inbound-Gateways](https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs/howto-k8s-ingress-gateway) oder in einem [Beispielmanifest](https://github.com/aws/aws-app-mesh-examples/blob/main/walkthroughs/howto-k8s-ingress-gateway/v1beta2/manifest.yaml.template), das die Ressourcen für enthält. GitHub
## Schritt 3: Erstellen oder Aktualisieren von Services
Allen Pods, die Sie mit App Mesh verwenden möchten, müssen die App Mesh-Sidecar-Container hinzugefügt werden. Der Injektor fügt die Sidecar-Container automatisch jedem Pod hinzu, der mit einer von Ihnen angegebenen Beschriftung bereitgestellt wird.
1. Proxy-Autorisierung aktivieren. Wir empfehlen, dass Sie für jede Kubernetes-Bereitstellung nur die Konfiguration für ihren eigenen virtuellen App Mesh-Knoten streamen.
1. Speichern Sie den folgenden Inhalt in einer Datei mit dem Namen `proxy-auth.json` auf Ihrem Computer. Stellen Sie sicher, dass Sie den durch Ihren *alternate-colored values* eigenen ersetzen.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "appmesh:StreamAggregatedResources",
"Resource": [
"arn:aws:appmesh:us-east-1:111122223333:mesh/my-mesh/virtualNode/my-service-a_my-apps"
]
}
]
}
```
------
1. Erstellen Sie die Richtlinie.
```
aws iam create-policy --policy-name my-policy --policy-document file://proxy-auth.json
```
1. Erstellen Sie eine IAM-Rolle, fügen Sie ihr die im vorherigen Schritt erstellte Richtlinie hinzu, erstellen Sie ein Kubernetes-Dienstkonto und binden Sie die Richtlinie an das Kubernetes-Dienstkonto. Die Rolle ermöglicht es dem Controller, App Mesh-Ressourcen hinzuzufügen, zu entfernen und zu ändern.
```
eksctl create iamserviceaccount \
--cluster $CLUSTER_NAME \
--namespace my-apps \
--name my-service-a \
--attach-policy-arn arn:aws:iam::111122223333:policy/my-policy \
--override-existing-serviceaccounts \
--approve
```
Wenn Sie das Servicekonto lieber mit dem AWS-Managementkonsole oder erstellen möchten AWS CLI, finden Sie weitere Informationen unter [Erstellen einer IAM-Rolle und -Richtlinie für Ihr Servicekonto](https://docs.aws.amazon.com/eks/latest/userguide/create-service-account-iam-policy-and-role.html#create-service-account-iam-role) im *Amazon EKS-Benutzerhandbuch*. Wenn Sie das AWS-Managementkonsole oder verwenden, AWS CLI um das Konto zu erstellen, müssen Sie die Rolle auch einem Kubernetes-Servicekonto zuordnen. Weitere Informationen finden Sie unter [Angeben einer IAM-Rolle für Ihr Servicekonto](https://docs.aws.amazon.com/eks/latest/userguide/specify-service-account-role.html) im *Amazon EKS-Benutzerhandbuch*.
1. (Optional) Wenn Sie Ihre Bereitstellung auf Fargate-Pods bereitstellen möchten, müssen Sie ein Fargate-Profil erstellen. Wenn Sie es noch nicht `eksctl` installiert haben, können Sie es mithilfe der Anweisungen unter [Installation oder Upgrade `eksctl`](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html#installing-eksctl) im *Amazon EKS-Benutzerhandbuch* installieren. Wenn Sie das Profil lieber mit der Konsole erstellen möchten, finden Sie weitere Informationen unter [Erstellen eines Fargate-Profils](https://docs.aws.amazon.com/eks/latest/userguide/fargate-profile.html#create-fargate-profile) im *Amazon EKS-Benutzerhandbuch*.
```
eksctl create fargateprofile --cluster my-cluster --region Region-code --name my-service-a --namespace my-apps
```
1. Erstellen Sie einen Kubernetes-Service und eine entsprechende Bereitstellung. Wenn Sie über eine bestehende Bereitstellung verfügen, die Sie mit App Mesh verwenden möchten, müssen Sie einen virtuellen Knoten bereitstellen, wie Sie es im Unterschritt `3` von [Schritt 2: App Mesh Mesh-Ressourcen bereitstellen](#configure-app-mesh) getan haben. Aktualisieren Sie Ihre Bereitstellung, um sicherzustellen, dass das Label mit dem Label übereinstimmt, das Sie für den virtuellen Knoten festgelegt haben, sodass die Sidecar-Container automatisch zu den Pods hinzugefügt und die Pods erneut bereitgestellt werden.
1. Speichern Sie den folgenden Inhalt in einer Datei mit dem Namen `example-service.yaml` auf Ihrem Computer. Wenn Sie den Namespace-Namen ändern und Fargate-Pods verwenden, stellen Sie sicher, dass der Namespace-Name mit dem Namespace-Namen übereinstimmt, den Sie in Ihrem Fargate-Profil definiert haben.
```
apiVersion: v1
kind: Service
metadata:
name: my-service-a
namespace: my-apps
labels:
app: my-app-1
spec:
selector:
app: my-app-1
ports:
- protocol: TCP
port: 80
targetPort: 80
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: my-service-a
namespace: my-apps
labels:
app: my-app-1
spec:
replicas: 3
selector:
matchLabels:
app: my-app-1
template:
metadata:
labels:
app: my-app-1
spec:
serviceAccountName: my-service-a
containers:
- name: nginx
image: nginx:1.19.0
ports:
- containerPort: 80
```
**Wichtig**
Der Wert für die `app` `matchLabels` `selector` in der Spezifikation muss mit dem Wert übereinstimmen, den Sie beim Erstellen des virtuellen Knotens im Teilschritt `3` von [Schritt 2: App Mesh Mesh-Ressourcen bereitstellen](#configure-app-mesh) angegeben haben, anderenfalls werden die Sidecar-Container nicht in den Pod injiziert. Im vorherigen Beispiel lautet der Wert für die Beschriftung `my-app-1`. Wenn Sie ein virtuelles Gateway anstelle eines virtuellen Knotens bereitstellen, sollte das `Deployment` Manifest nur den Envoy-Container enthalten. Weitere Informationen zu dem zu verwendenden Image finden Sie unter[Bild des Gesandten](envoy.md). Ein Beispiel für ein Manifest finden Sie im [Bereitstellungsbeispiel](https://github.com/aws/aws-app-mesh-examples/blob/main/walkthroughs/howto-k8s-ingress-gateway/v1beta2/manifest.yaml.template#L585) unter GitHub.
1. Bereitstellen des Services.
```
kubectl apply -f example-service.yaml
```
1. Zeigen Sie den Service und die Bereitstellung an.
```
kubectl -n my-apps get pods
```
Ausgabe
```
NAME READY STATUS RESTARTS AGE
my-service-a-54776556f6-2cxd9 2/2 Running 0 10s
my-service-a-54776556f6-w26kf 2/2 Running 0 18s
my-service-a-54776556f6-zw5kt 2/2 Running 0 26s
```
1. Zeigen Sie die Details zu einem der bereitgestellten Pods an.
```
kubectl -n my-apps describe pod my-service-a-54776556f6-2cxd9
```
Gekürzte Ausgabe
```
Name: my-service-a-54776556f6-2cxd9
Namespace: my-app-1
Priority: 0
Node: ip-192-168-44-157.us-west-2.compute.internal/192.168.44.157
Start Time: Wed, 17 Jun 2020 11:08:59 -0500
Labels: app=nginx
pod-template-hash=54776556f6
Annotations: kubernetes.io/psp: eks.privileged
Status: Running
IP: 192.168.57.134
IPs:
IP: 192.168.57.134
Controlled By: ReplicaSet/my-service-a-54776556f6
Init Containers:
proxyinit:
Container ID: docker://e0c4810d584c21ae0cb6e40f6119d2508f029094d0e01c9411c6cf2a32d77a59
Image: 111345817488.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-proxy-route-manager:v2
Image ID: docker-pullable://111345817488.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-proxy-route-manager
Port:
Host Port:
State: Terminated
Reason: Completed
Exit Code: 0
Started: Fri, 26 Jun 2020 08:36:22 -0500
Finished: Fri, 26 Jun 2020 08:36:22 -0500
Ready: True
Restart Count: 0
Requests:
cpu: 10m
memory: 32Mi
Environment:
APPMESH_START_ENABLED: 1
APPMESH_IGNORE_UID: 1337
APPMESH_ENVOY_INGRESS_PORT: 15000
APPMESH_ENVOY_EGRESS_PORT: 15001
APPMESH_APP_PORTS: 80
APPMESH_EGRESS_IGNORED_IP: 169.254.169.254
APPMESH_EGRESS_IGNORED_PORTS: 22
AWS_ROLE_ARN: arn:aws:iam::111122223333:role/eksctl-app-mesh-addon-iamserviceaccount-my-a-Role1-NMNCVWB6PL0N
AWS_WEB_IDENTITY_TOKEN_FILE: /var/run/secrets/eks.amazonaws.com/serviceaccount/token
...
Containers:
nginx:
Container ID: docker://be6359dc6ecd3f18a1c87df7b57c2093e1f9db17d5b3a77f22585ce3bcab137a
Image: nginx:1.19.0
Image ID: docker-pullable://nginx
Port: 80/TCP
Host Port: 0/TCP
State: Running
Started: Fri, 26 Jun 2020 08:36:28 -0500
Ready: True
Restart Count: 0
Environment:
AWS_ROLE_ARN: arn:aws:iam::111122223333:role/eksctl-app-mesh-addon-iamserviceaccount-my-a-Role1-NMNCVWB6PL0N
AWS_WEB_IDENTITY_TOKEN_FILE: /var/run/secrets/eks.amazonaws.com/serviceaccount/token
...
envoy:
Container ID: docker://905b55cbf33ef3b3debc51cb448401d24e2e7c2dbfc6a9754a2c49dd55a216b6
Image: 840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.12.4.0-prod
Image ID: docker-pullable://840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy
Port: 9901/TCP
Host Port: 0/TCP
State: Running
Started: Fri, 26 Jun 2020 08:36:36 -0500
Ready: True
Restart Count: 0
Requests:
cpu: 10m
memory: 32Mi
Environment:
APPMESH_RESOURCE_ARN: arn:aws:iam::111122223333:mesh/my-mesh/virtualNode/my-service-a_my-apps
APPMESH_PREVIEW: 0
ENVOY_LOG_LEVEL: info
AWS_REGION: us-west-2
AWS_ROLE_ARN: arn:aws:iam::111122223333:role/eksctl-app-mesh-addon-iamserviceaccount-my-a-Role1-NMNCVWB6PL0N
AWS_WEB_IDENTITY_TOKEN_FILE: /var/run/secrets/eks.amazonaws.com/serviceaccount/token
...
Events:
Type Reason Age From Message
---- ------ ---- ---- -------
Normal Pulling 30s kubelet, ip-192-168-44-157.us-west-2.compute.internal Pulling image "111345817488.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-proxy-route-manager:v2"
Normal Pulled 23s kubelet, ip-192-168-44-157.us-west-2.compute.internal Successfully pulled image "111345817488.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-proxy-route-manager:v2"
Normal Created 21s kubelet, ip-192-168-44-157.us-west-2.compute.internal Created container proxyinit
Normal Started 21s kubelet, ip-192-168-44-157.us-west-2.compute.internal Started container proxyinit
Normal Pulling 20s kubelet, ip-192-168-44-157.us-west-2.compute.internal Pulling image "nginx:1.19.0"
Normal Pulled 16s kubelet, ip-192-168-44-157.us-west-2.compute.internal Successfully pulled image "nginx:1.19.0"
Normal Created 15s kubelet, ip-192-168-44-157.us-west-2.compute.internal Created container nginx
Normal Started 15s kubelet, ip-192-168-44-157.us-west-2.compute.internal Started container nginx
Normal Pulling 15s kubelet, ip-192-168-44-157.us-west-2.compute.internal Pulling image "840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.12.4.0-prod"
Normal Pulled 8s kubelet, ip-192-168-44-157.us-west-2.compute.internal Successfully pulled image "840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.12.4.0-prod"
Normal Created 7s kubelet, ip-192-168-44-157.us-west-2.compute.internal Created container envoy
Normal Started 7s kubelet, ip-192-168-44-157.us-west-2.compute.internal Started container envoy
```
In der vorherigen Ausgabe können Sie sehen, dass die Container `proxyinit` und `envoy` vom Controller dem Pod hinzugefügt wurden. Wenn Sie den Beispieldienst in Fargate bereitgestellt haben, wurde der `envoy` Container vom Controller zum Pod hinzugefügt, der `proxyinit` Container jedoch nicht.
1. (Optional) Installieren Sie Add-Ons wie Prometheus, Grafana AWS X-Ray, Jaeger und Datadog. Weitere Informationen finden Sie unter [App Mesh-Add-Ons](https://github.com/aws/eks-charts#app-mesh-add-ons) auf GitHub und im Abschnitt [Observability](https://docs.aws.amazon.com/app-mesh/latest/userguide/observability.html) im App Mesh Mesh-Benutzerhandbuch.
**Anmerkung**
Weitere Beispiele und Komplettlösungen für App Mesh finden Sie im App Mesh [Mesh-Beispiel-Repository](https://github.com/aws/aws-app-mesh-examples).
## Schritt 4: Bereinigen
Entfernen Sie alle Beispielressourcen, die in diesem Tutorial erstellt wurden. Der Controller entfernt auch die Ressourcen, die im `my-mesh` App Mesh Service Mesh erstellt wurden.
```
kubectl delete namespace my-apps
```
Wenn Sie ein Fargate-Profil für den Beispieldienst erstellt haben, entfernen Sie es.
```
eksctl delete fargateprofile --name my-service-a --cluster my-cluster --region Region-code
```
Löschen Sie das Mesh.
```
kubectl delete mesh my-mesh
```
(Optional) Sie können die Kubernetes-Integrationskomponenten entfernen.
```
helm delete appmesh-controller -n appmesh-system
```
(Optional) Wenn Sie die Kubernetes-Integrationskomponenten in Fargate bereitgestellt haben, löschen Sie das Fargate-Profil.
```
eksctl delete fargateprofile --name appmesh-system --cluster my-cluster --region Region-code
```
# Erste Schritte mit AWS App Mesh Amazon EC2
**Wichtig**
Hinweis zum Ende des Supports: Am 30. September 2026 AWS wird der Support für eingestellt. AWS App Mesh Nach dem 30. September 2026 können Sie nicht mehr auf die AWS App Mesh Konsole oder die Ressourcen zugreifen. AWS App Mesh Weitere Informationen finden Sie in diesem Blogbeitrag [Migration von AWS App Mesh zu Amazon ECS Service Connect](https://aws.amazon.com/blogs/containers/migrating-from-aws-app-mesh-to-amazon-ecs-service-connect).
Dieses Thema hilft Ihnen bei der Verwendung AWS App Mesh mit einem tatsächlichen Service, der auf Amazon EC2 läuft. Dieses Tutorial behandelt die grundlegenden Funktionen verschiedener App Mesh Mesh-Ressourcentypen.
## Szenario
Gehen Sie zur Veranschaulichung der Verwendung von App Mesh davon aus, dass Sie über eine Anwendung mit den folgenden Eigenschaften verfügen:
+ Besteht aus zwei Diensten mit dem Namen `serviceA` und`serviceB`.
+ Beide Services sind in einem Namespace namens `apps.local` registriert.
+ `ServiceA` kommuniziert mit `serviceB` über HTTP/2, Port 80.
+ Sie haben bereits Version 2 von `serviceB` bereitgestellt und mit dem Namen `serviceBv2` im `apps.local`-Namespace registriert.
Es gelten die folgenden Anforderungen:
+ Sie möchten 75 Prozent des Datenverkehrs von `serviceA` bis `serviceB` und 25 Prozent des Datenverkehrs an `serviceBv2` First weiterleiten. Wenn Sie nur 25 Prozent des Datenverkehrs an senden`serviceBv2`, können Sie überprüfen, ob es fehlerfrei ist, bevor Sie 100 Prozent des Datenverkehrs von senden`serviceA`.
+ Sie möchten in der Lage sein, die Datenverkehrsgewichtung so anzupassen, dass 100 Prozent des Datenverkehrs an `serviceBv2` gehen, sobald sich die Zuverlässigkeit davon erwiesen hat. Sobald der gesamte Datenverkehr an gesendet wurde`serviceBv2`, möchten Sie den Vorgang beenden`serviceB`.
+ Sie möchten für Ihre eigentlichen Dienste keinen bestehenden Anwendungscode oder eine Registrierung zur Serviceerkennung ändern müssen, um die vorherigen Anforderungen zu erfüllen.
Um Ihren Anforderungen gerecht zu werden, entscheiden Sie sich dafür, ein App Mesh Service Mesh mit virtuellen Diensten, virtuellen Knoten, einem virtuellen Router und einer Route zu erstellen. Nach der Implementierung Ihres Meshs aktualisieren Sie Ihre Dienste so, dass sie den Envoy-Proxy verwenden. Nach der Aktualisierung kommunizieren Ihre Services miteinander über den Envoy-Proxy und nicht direkt miteinander.
## Voraussetzungen
App Mesh unterstützt Linux-Dienste, die mit DNS oder beidem registriert sind. AWS Cloud Map Um dieses Handbuch für Erste Schritte zu verwenden, empfehlen wir, dass Sie über drei vorhandene Services verfügen, die bei DNS registriert sind. Sie können ein Service-Mesh und seine Ressourcen erstellen, auch wenn die Services nicht vorhanden sind. Sie können das Mesh jedoch erst verwenden, wenn Sie tatsächliche Services bereitgestellt haben.
Wenn Sie noch keine Dienste ausführen, können Sie Amazon EC2 EC2-Instances starten und Anwendungen für sie bereitstellen. Weitere Informationen finden Sie unter [Tutorial: Erste Schritte mit Amazon EC2 EC2-Linux-Instances](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-lamp-amazon-linux-2.html) im Amazon EC2 EC2-Benutzerhandbuch. Die verbleibenden Schritte gehen davon aus, dass die tatsächlichen Services als `serviceA`, `serviceB` und `serviceBv2` benannt sind, und dass alle Services über einen Namespace mit dem Namen `apps.local` gefunden werden können.
## Schritt 1: Erstellen von einem Mesh und einem virtuellen Service
Ein Service Mesh ist eine logische Begrenzung für den Netzwerkdatenverkehr zwischen den darin vorhandenen Services. Weitere Informationen finden Sie unter [Servicenetze](meshes.md). Ein virtueller Service ist eine Abstraktion eines tatsächlichen Services. Weitere Informationen finden Sie unter [Virtuelle Dienste](virtual_services.md).
Erstellen Sie die folgenden Ressourcen:
+ Ein Mesh mit dem Namen `apps`, da alle Services im Szenario im `apps.local`-Namespace registriert sind.
+ Einen virtuellen Service mit dem Namen `serviceb.apps.local`, da der virtuelle Service einen Service darstellt, der mit diesem Namen gefunden werden kann, und Sie Ihren Code nicht ändern möchten, um auf einen anderen Namen zu verweisen. Ein virtueller Service mit dem Namen `servicea.apps.local` wird in einem späteren Schritt hinzugefügt.
Sie können die AWS-Managementkonsole oder die AWS CLI Version 1.18.116 oder höher oder 2.0.38 oder höher verwenden, um die folgenden Schritte auszuführen. Wenn Sie die verwenden AWS CLI, verwenden Sie den `aws --version` Befehl, um Ihre installierte Version zu überprüfen. AWS CLI Wenn Sie Version 1.18.116 oder höher oder 2.0.38 oder höher nicht installiert haben, müssen Sie die [installieren oder aktualisieren](https://docs.aws.amazon.com/cli/latest/reference/appmesh/cli-chap-install.html). AWS CLI Wählen Sie die Registerkarte für das Werkzeug aus, das Sie verwenden möchten.
------
#### [ AWS-Managementkonsole ]
1. Öffnen Sie bei den ersten Schritten den Assistenten für die erste Ausführung der App Mesh Mesh-Konsole [https://console.aws.amazon.com/appmesh/.](https://console.aws.amazon.com/appmesh/get-started)
1. Geben Sie unter **Mesh name (Mesh-Name)** **apps** ein.
1. Geben Sie unter **Virtual service name (Name des virtuellen Services)** **serviceb.apps.local** ein.
1. Wählen Sie **Next**, um fortzufahren.
------
#### [ AWS CLI ]
1. Erstellen Sie mit dem `[create-mesh](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-mesh.html)`-Befehl ein Mesh.
```
aws appmesh create-mesh --mesh-name apps
```
1. Erstellen Sie einen virtuellen Service mit dem `[create-virtual-service](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-virtual-service.html)`-Befehl.
```
aws appmesh create-virtual-service --mesh-name apps --virtual-service-name serviceb.apps.local --spec {}
```
------
## Schritt 2: Erstellen von einem virtuellen Knoten
Ein virtueller Knoten fungiert als ein logischer Verweis auf einen tatsächlichen Service. Weitere Informationen finden Sie unter [Virtuelle Knoten](virtual_nodes.md).
Erstellen Sie einen virtuellen Knoten mit dem Namen `serviceB`, da einer der virtuellen Knoten den tatsächlichen Service mit dem Namen `serviceB` darstellt. Der tatsächliche Service, den der virtuelle Knoten darstellt, kann über `DNS` mit dem Hostnamen von `serviceb.apps.local` gefunden werden. Alternativ können Sie tatsächliche Services mit AWS Cloud Map finden. Der virtuelle Knoten überwacht den Datenverkehr über das HTTP/2-Protokoll an Port 80. Auch andere Protokolle werden unterstützt, ebenso wie Zustandsprüfungen. Sie erstellen virtuelle Knoten für `serviceA` und `serviceBv2` in einem späteren Schritt.
------
#### [ AWS-Managementkonsole ]
1. Geben Sie unter **Virtual node name (Name des virtuellen Knotens)** **serviceB** ein.
1. Wählen Sie unter **Service discovery method (Serviceerkennungsverfahren)** die Option **DNS** aus, und geben Sie **serviceb.apps.local** als **DNS hostname (DNS-Hostname)** ein.
1. **Wählen Sie unter **Listener-Konfiguration** **http2** als **Protokoll** und geben Sie **80** für Port ein.**
1. Wählen Sie **Next**, um fortzufahren.
------
#### [ AWS CLI ]
1. Erstellen Sie eine Datei `create-virtual-node-serviceb.json` mit dem folgenden Inhalt:
```
{
"meshName": "apps",
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http2"
}
}
],
"serviceDiscovery": {
"dns": {
"hostname": "serviceB.apps.local"
}
}
},
"virtualNodeName": "serviceB"
}
```
1. Erstellen Sie den virtuellen Knoten mit dem [create-virtual-node](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-virtual-node.html)Befehl und verwenden Sie dabei die JSON-Datei als Eingabe.
```
aws appmesh create-virtual-node --cli-input-json file://create-virtual-node-serviceb.json
```
------
## Schritt 3: Erstellen von einem virtuellen Router und einer Route
Virtuelle Router routen den Datenverkehr für einen oder mehrere virtuelle Services innerhalb Ihres Meshes. Weitere Informationen erhalten Sie unter [Virtuelle Router](virtual_routers.md) und [Routen](routes.md).
Erstellen Sie die folgenden Ressourcen:
+ Einen virtuellen Router mit dem Namen `serviceB`, da der virtuelle `serviceB.apps.local`-Service keine ausgehende Kommunikation mit einem anderen Service initiiert. Denken Sie daran, dass der virtuelle Service, den Sie zuvor erstellt haben, eine Abstraktion Ihres tatsächlichen `serviceb.apps.local`-Services ist. Der virtuelle Service sendet Datenverkehr an den virtuellen Router. Der virtuelle Router überwacht den Datenverkehr mithilfe des HTTP/2-Protokolls an Port 80. Andere Protokolle werden ebenfalls unterstützt.
+ Eine Route namens `serviceB`. Er leitet 100 Prozent seines Datenverkehrs an den `serviceB` virtuellen Knoten weiter. Die Gewichtung erfolgt in einem späteren Schritt, sobald Sie den `serviceBv2` virtuellen Knoten hinzugefügt haben. Obwohl in diesem Handbuch nicht behandelt, können Sie zusätzliche Filterkriterien für die Route hinzufügen und eine Wiederholungsrichtlinie hinzufügen, damit der Envoy-Proxy mehrere Versuche unternimmt, Datenverkehr an einen virtuellen Knoten zu senden, wenn ein Kommunikationsproblem auftritt.
------
#### [ AWS-Managementkonsole ]
1. Geben Sie für **Virtual router name (Name des virtuellen Routers)** **serviceB** ein.
1. **Wählen Sie unter **Listener-Konfiguration** **http2** als **Protokoll** und geben Sie als Port **80** an.**
1. Geben Sie unter **Route name (Name der Route)** **serviceB** ein.
1. Wählen Sie für **Route type (Routentyp)** die Option **http2**.
1. **Wählen Sie für den **Namen des virtuellen Knotens** unter **Zielkonfiguration** die Option Gewicht aus `serviceB` und geben **100** Sie den Wert ein.**
1. Wählen Sie unter **Konfiguration anpassen** eine **Methode** aus.
1. Wählen Sie **Next**, um fortzufahren.
------
#### [ AWS CLI ]
1. Erstellen Sie einen virtuellen Router.
1. Erstellen Sie eine Datei `create-virtual-router.json` mit dem folgenden Inhalt:
```
{
"meshName": "apps",
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http2"
}
}
]
},
"virtualRouterName": "serviceB"
}
```
1. Erstellen Sie den virtuellen Router mit dem [create-virtual-router](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-virtual-router.html)Befehl und verwenden Sie dabei die JSON-Datei als Eingabe.
```
aws appmesh create-virtual-router --cli-input-json file://create-virtual-router.json
```
1. Erstellen Sie eine Route.
1. Erstellen Sie eine Datei `create-route.json` mit dem folgenden Inhalt:
```
{
"meshName" : "apps",
"routeName" : "serviceB",
"spec" : {
"httpRoute" : {
"action" : {
"weightedTargets" : [
{
"virtualNode" : "serviceB",
"weight" : 100
}
]
},
"match" : {
"prefix" : "/"
}
}
},
"virtualRouterName" : "serviceB"
}
```
1. Erstellen Sie die Route mit dem Befehl [create-route](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-route.html) unter Verwendung der JSON-Datei als Eingabe.
```
aws appmesh create-route --cli-input-json file://create-route.json
```
------
## Schritt 4: Überprüfen und Erstellen
Überprüfen Sie die Einstellungen anhand der vorherigen Anweisungen.
------
#### [ AWS-Managementkonsole ]
Wählen Sie **Edit (Bearbeiten)** aus, wenn Sie Änderungen in einem Abschnitt vornehmen müssen. Sobald Sie mit den Einstellungen zufrieden sind, wählen Sie **Create mesh (Netz erstellen)** aus.
Im Fenster **Status** werden alle erstellten Netzressourcen angezeigt. Sie können die erstellten Ressourcen in der Konsole anzeigen, indem Sie **View mesh (Netz anzeigen)** auswählen.
------
#### [ AWS CLI ]
Überprüfen Sie die Einstellungen des Meshes, das Sie erstellt haben, mit dem Befehl [describe-mesh](https://docs.aws.amazon.com/cli/latest/reference/appmesh/describe-mesh.html).
```
aws appmesh describe-mesh --mesh-name apps
```
Überprüfen Sie die Einstellungen des virtuellen Dienstes, den Sie mit dem [describe-virtual-service](https://docs.aws.amazon.com/cli/latest/reference/appmesh/describe-virtual-service.html)Befehl erstellt haben.
```
aws appmesh describe-virtual-service --mesh-name apps --virtual-service-name serviceb.apps.local
```
Überprüfen Sie die Einstellungen des virtuellen Knotens, den Sie mit dem [describe-virtual-node](https://docs.aws.amazon.com/cli/latest/reference/appmesh/describe-virtual-node.html)Befehl erstellt haben.
```
aws appmesh describe-virtual-node --mesh-name apps --virtual-node-name serviceB
```
Überprüfen Sie die Einstellungen des virtuellen Routers, den Sie mit dem [describe-virtual-router](https://docs.aws.amazon.com/cli/latest/reference/appmesh/describe-virtual-router.html)Befehl erstellt haben.
```
aws appmesh describe-virtual-router --mesh-name apps --virtual-router-name serviceB
```
Überprüfen Sie die Einstellungen der Route, die Sie erstellt haben, mit dem Befehl [describe-route](https://docs.aws.amazon.com/cli/latest/reference/appmesh/describe-route.html).
```
aws appmesh describe-route --mesh-name apps \
--virtual-router-name serviceB --route-name serviceB
```
------
## Schritt 5: Erstellen zusätzlicher Ressourcen
Um das Szenario abzuschließen, müssen Sie:
+ Einen virtuellen Knoten mit dem Namen `serviceBv2` und einen anderen mit dem Namen `serviceA` erstellen. Beide virtuellen Knoten warten auf Anfragen über HTTP/2-Port 80. Konfigurieren Sie für den `serviceA` virtuellen Knoten ein Backend von`serviceb.apps.local`. Der gesamte ausgehende Datenverkehr vom `serviceA` virtuellen Knoten wird an den genannten virtuellen Dienst gesendet. `serviceb.apps.local` Obwohl dies in diesem Handbuch nicht behandelt wird, können Sie auch einen Dateipfad angeben, in den Zugriffsprotokolle für einen virtuellen Knoten geschrieben werden sollen.
+ Erstellen Sie einen zusätzlichen virtuellen Dienst mit dem Namen`servicea.apps.local`, der den gesamten Datenverkehr direkt an den `serviceA` virtuellen Knoten sendet.
+ Aktualisieren Sie die `serviceB`-Route, die Sie in einem vorherigen Schritt erstellt haben, so, dass 75 Prozent des Datenverkehrs an den virtuellen `serviceB`- Knoten und 25 Prozent des Datenverkehrs an den virtuellen `serviceBv2`-Knoten gesendet werden. Im Laufe der Zeit können Sie die Gewichtungen weiter ändern, bis `serviceBv2` 100 Prozent des Datenverkehrs erhält. Sobald der gesamte Datenverkehr an gesendet wurde`serviceBv2`, können Sie den `serviceB` virtuellen Knoten und den eigentlichen Dienst herunterfahren und beenden. Wenn Sie Gewichtungen ändern, erfordert Ihr Code keine Änderung, da sich die Namen des virtuellen `serviceb.apps.local`- und des tatsächlichen Services nicht ändern. Denken Sie daran, dass der virtuelle `serviceb.apps.local`-Service Datenverkehr an den virtuellen Router sendet, der den Datenverkehr an die virtuellen Knoten weiterleitet. Die Serviceerkennungsnamen für die virtuellen Knoten können jederzeit geändert werden.
------
#### [ AWS-Managementkonsole ]
1. Wählen Sie im linken Navigationsbereich **Meshes**.
1. Wählen Sie das `apps`-Mesh aus, das Sie in einem vorherigen Schritt erstellt haben.
1. Wählen Sie im linken Navigationsbereich **Virtual nodes (Virtuelle Knoten)** aus.
1. Wählen Sie **Create virtual node (Virtuellen Knoten erstellen)**.
1. Geben Sie unter **Virtual node name (Name des virtuellen Knotens)** **serviceBv2** ein, wählen Sie für **Service discovery method (Serviceerkennungsverfahren)** die Option **DNS** aus, und geben Sie für den **DNS hostname (DNS-Hostname)** **servicebv2.apps.local** ein.
1. **Wählen Sie für die **Listener-Konfiguration** **http2** als **Protokoll** und geben Sie **80** für Port ein.**
1. Wählen Sie **Create virtual node (Virtuellen Knoten erstellen)**.
1. Wählen Sie erneut **Create virtual node (Virtuellen Knoten erstellen)** aus. Geben Sie „**serviceA**“ als **Virtual node name (Name des virtuellen Knotens)** ein. Wählen Sie als **Service discovery method (Diensterkennungsmethode)** die Option **DNS** ein, und geben Sie als **DNS hostname (DNS-Hostname)** den Wert „**servicea.apps.local**“ ein.
1. Geben Sie bei **Enter a virtual service name (Neuen virtuellen Service-Name eingeben)** unter **New backend (Neues Backend)** den Wert „**serviceb.apps.local**“ ein.
1. Wählen Sie unter **Listener configuration (Listener-Konfiguration)** die Option **http2** für **Protocol (Protokoll)** aus, geben Sie „**80**“ bei **Port** ein, und wählen Sie dann **Create virtual node (Virtuellen Knoten erstellen)** aus.
1. Wählen Sie im linken Navigationsbereich **Virtual routers (Virtuelle Router)** aus, und wählen Sie dann den virtuellen Router `serviceB` aus der Liste aus.
1. Wählen Sie unter **Routes (Routen)** die Route `ServiceB` aus, die Sie in einem vorherigen Schritt erstellt haben, und wählen Sie dann **Edit (Bearbeiten)** aus.
1. Ändern Sie unter **Targets (Ziele)**, **Virtual node name (Name des virtuellen Knotens)** den Wert von **Weight (Gewicht)** für `serviceB` zu **75**.
1. **Wählen Sie **Ziel hinzufügen**, wählen Sie `serviceBv2` aus der Dropdownliste und legen Sie den Wert für Weight auf fest.** **25**
1. Wählen Sie **Speichern**.
1. Wählen Sie im linken Navigationsbereich **Virtual services (Virtuelle Services)** aus, und wählen Sie dann **Create virtual service (Virtuellen Dienst erstellen)** aus.
1. Geben Sie „**servicea.apps.local**“ bei **Virtual service name (Virtueller Dienstname)** ein, wählen Sie **Virtual node (Virtueller Knoten)** als **Provider (Anbieter)**, wählen Sie „`serviceA`“ bei **Virtual node (Virtueller Knoten)** und dann **Create virtual service (Virtuellen Dienst erstellen)** aus.
------
#### [ AWS CLI ]
1. Erstellen Sie den virtuellen Knoten `serviceBv2`.
1. Erstellen Sie eine Datei `create-virtual-node-servicebv2.json` mit dem folgenden Inhalt:
```
{
"meshName": "apps",
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http2"
}
}
],
"serviceDiscovery": {
"dns": {
"hostname": "serviceBv2.apps.local"
}
}
},
"virtualNodeName": "serviceBv2"
}
```
1. Erstellen Sie den virtuellen Knoten.
```
aws appmesh create-virtual-node --cli-input-json file://create-virtual-node-servicebv2.json
```
1. Erstellen Sie den virtuellen Knoten `serviceA`.
1. Erstellen Sie eine Datei `create-virtual-node-servicea.json` mit dem folgenden Inhalt:
```
{
"meshName" : "apps",
"spec" : {
"backends" : [
{
"virtualService" : {
"virtualServiceName" : "serviceb.apps.local"
}
}
],
"listeners" : [
{
"portMapping" : {
"port" : 80,
"protocol" : "http2"
}
}
],
"serviceDiscovery" : {
"dns" : {
"hostname" : "servicea.apps.local"
}
}
},
"virtualNodeName" : "serviceA"
}
```
1. Erstellen Sie den virtuellen Knoten.
```
aws appmesh create-virtual-node --cli-input-json file://create-virtual-node-servicea.json
```
1. Aktualisieren Sie den virtuellen Service `serviceb.apps.local`, den Sie in einem vorherigen Schritt erstellt haben, um seinen Datenverkehr an den virtuellen Router `serviceB` zu senden. Als der virtuelle Service ursprünglich erstellt wurde, sendete er keinen Datenverkehr, da der virtuelle Router `serviceB` noch nicht erstellt war.
1. Erstellen Sie eine Datei `update-virtual-service.json` mit dem folgenden Inhalt:
```
{
"meshName" : "apps",
"spec" : {
"provider" : {
"virtualRouter" : {
"virtualRouterName" : "serviceB"
}
}
},
"virtualServiceName" : "serviceb.apps.local"
}
```
1. Aktualisieren Sie den virtuellen Dienst mit dem [update-virtual-service](https://docs.aws.amazon.com/cli/latest/reference/appmesh/update-virtual-service.html)Befehl.
```
aws appmesh update-virtual-service --cli-input-json file://update-virtual-service.json
```
1. Aktualisieren Sie die Route `serviceB`, die Sie in einem vorherigen Schritt erstellt haben.
1. Erstellen Sie eine Datei `update-route.json` mit dem folgenden Inhalt:
```
{
"meshName" : "apps",
"routeName" : "serviceB",
"spec" : {
"http2Route" : {
"action" : {
"weightedTargets" : [
{
"virtualNode" : "serviceB",
"weight" : 75
},
{
"virtualNode" : "serviceBv2",
"weight" : 25
}
]
},
"match" : {
"prefix" : "/"
}
}
},
"virtualRouterName" : "serviceB"
}
```
1. Aktualisieren Sie die Route mit dem Befehl [update-route](https://docs.aws.amazon.com/cli/latest/reference/appmesh/update-route.html) .
```
aws appmesh update-route --cli-input-json file://update-route.json
```
1. Erstellen Sie den virtuellen Service `serviceA`.
1. Erstellen Sie eine Datei `create-virtual-servicea.json` mit dem folgenden Inhalt:
```
{
"meshName" : "apps",
"spec" : {
"provider" : {
"virtualNode" : {
"virtualNodeName" : "serviceA"
}
}
},
"virtualServiceName" : "servicea.apps.local"
}
```
1. Erstellen Sie den virtuellen Service.
```
aws appmesh create-virtual-service --cli-input-json file://create-virtual-servicea.json
```
------
**Mesh-Zusammenfassung**
Bevor Sie das Service-Mesh erstellt haben, hatten Sie drei aktuelle Services mit den Namen `servicea.apps.local`, `serviceb.apps.local` und `servicebv2.apps.local`. Zusätzlich zu den tatsächlichen Services verfügen Sie jetzt über ein Service-Mesh, das die folgenden Ressourcen enthält, die die tatsächlichen Services darstellen:
+ Zwei virtuelle Services. Der Proxy sendet den gesamten Datenverkehr vom virtuellen Service `servicea.apps.local` über einen virtuellen Router an den virtuellen Service `serviceb.apps.local`.
+ Drei virtuelle Knoten mit den Namen `serviceA`, `serviceB` und `serviceBv2`. Der Envoy-Proxy verwendet die für die virtuellen Knoten konfigurierten Service-Erkennungsinformationen, um die IP-Adressen der tatsächlichen Services zu suchen.
+ Einen virtuellen Router mit einer Route, die den Envoy-Proxy anweist, 75 Prozent des eingehenden Datenverkehrs an den virtuellen Knoten `serviceB` und 25 Prozent des Datenverkehrs an den virtuellen Knoten `serviceBv2` zu leiten.
## Schritt 6: Aktualisieren der Services
Nachdem Sie Ihr Mesh erstellt haben, müssen Sie die folgenden Aufgaben ausführen:
+ Autorisieren Sie den Envoy-Proxy, den Sie mit jedem Dienst bereitstellen, zum Lesen der Konfiguration eines oder mehrerer virtueller Knoten. Weitere Informationen zur Autorisierung des Proxys finden Sie unter. [Envoy Proxy-Autorisierung](proxy-authorization.md)
+ Gehen Sie wie folgt vor, um Ihren bestehenden Dienst zu aktualisieren.
**So konfigurieren Sie eine Amazon EC2 EC2-Instance als Mitglied eines virtuellen Knotens**
1. Erstellen Sie eine IAM-Rolle.
1. Erstellen Sie eine Datei mit dem Namen `ec2-trust-relationship.json` und dem folgenden Inhalt.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "ec2.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Erstellen Sie eine IAM-Rolle mit dem folgenden Befehl.
```
aws iam create-role --role-name mesh-virtual-node-service-b --assume-role-policy-document file://ec2-trust-relationship.json
```
1. Fügen Sie der Rolle IAM-Richtlinien hinzu, die es ihr ermöglichen, aus Amazon ECR und nur die Konfiguration eines bestimmten virtuellen App Mesh-Knotens zu lesen.
1. Erstellen Sie eine Datei namens „`virtual-node-policy.json`“ mit dem folgenden Inhalt. `apps` ist der Name des Netzes, das Sie in [Schritt 1: Erstellen von einem Mesh und einem virtuellen Service](#create-mesh-and-virtual-service) erstellt haben, und `serviceB` ist der Name des virtuellen Knotens, den Sie in [Schritt 2: Erstellen von einem virtuellen Knoten](#create-virtual-node) erstellt haben. *111122223333*Ersetzen Sie es durch Ihre Konto-ID und *us-west-2* durch die Region, in der Sie Ihr Mesh erstellt haben.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "appmesh:StreamAggregatedResources",
"Resource": [
"arn:aws:appmesh:us-west-2:111122223333:mesh/apps/virtualNode/serviceB"
]
}
]
}
```
------
1. Erstellen Sie die Richtlinie mit dem folgenden Befehl.
```
aws iam create-policy --policy-name virtual-node-policy --policy-document file://virtual-node-policy.json
```
1. Hängen Sie die Richtlinie, die Sie im vorherigen Schritt erstellt haben, an die Rolle an, sodass die Rolle die Konfiguration nur für den `serviceB` virtuellen Knoten aus App Mesh lesen kann.
```
aws iam attach-role-policy --policy-arn arn:aws:iam::111122223333:policy/virtual-node-policy --role-name mesh-virtual-node-service-b
```
1. Hängen Sie die `AmazonEC2ContainerRegistryReadOnly` verwaltete Richtlinie an die Rolle an, damit sie das Envoy-Container-Image aus Amazon ECR abrufen kann.
```
aws iam attach-role-policy --policy-arn arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryReadOnly --role-name mesh-virtual-node-service-b
```
1. [Starten Sie eine Amazon EC2 EC2-Instance mit der IAM-Rolle](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#launch-instance-with-role), die Sie erstellt haben.
1. Stellen Sie eine Verbindung zur Instance per SSH her.
1. Installieren Sie Docker und die AWS CLI auf Ihrer Instance gemäß Ihrer Betriebssystemdokumentation.
1. Authentifizieren Sie sich beim Envoy Amazon ECR-Repository in der Region, aus der Ihr Docker-Client das Image abrufen soll.
+ Alle Regionen außer`me-south-1`,,, `ap-east-1``ap-southeast-3`, `eu-south-1` und. `il-central-1` `af-south-1` Sie können es durch jede [unterstützte Region *us-west-2*](https://docs.aws.amazon.com/general/latest/gr/appmesh.html) mit Ausnahme von `me-south-1``ap-east-1`,`ap-southeast-3`,, `eu-south-1``il-central-1`, und ersetzen`af-south-1`.
```
$aws ecr get-login-password \
--region us-west-2 \
| docker login \
--username AWS \
--password-stdin 840364872350.dkr.ecr.us-west-2.amazonaws.com
```
+ `me-south-1`-Region
```
$aws ecr get-login-password \
--region me-south-1 \
| docker login \
--username AWS \
--password-stdin 772975370895.dkr.ecr.me-south-1.amazonaws.com
```
+ `ap-east-1`-Region
```
$aws ecr get-login-password \
--region ap-east-1 \
| docker login \
--username AWS \
--password-stdin 856666278305.dkr.ecr.ap-east-1.amazonaws.com
```
1. Führen Sie einen der folgenden Befehle aus, um den App Mesh Envoy-Container auf Ihrer Instance zu starten, je nachdem, aus welcher Region Sie das Image abrufen möchten. Die *serviceB* Werte *apps* und sind die im Szenario definierten Mesh- und virtuellen Knotennamen. Diese Information teilt dem Proxy mit, welche Konfiguration des virtuellen Knotens aus App Mesh gelesen werden soll. Um das Szenario abzuschließen, müssen Sie diese Schritte auch für die Amazon EC2 EC2-Instances ausführen, die die durch die virtuellen Knoten `serviceBv2` und die `serviceA` virtuellen Knoten repräsentierten Dienste hosten. Ersetzen Sie diese Werte für Ihre eigene Anwendung durch Ihre eigenen.
+ Alle Regionen außer `me-south-1``ap-east-1`,`ap-southeast-3`, `eu-south-1``il-central-1`, und`af-south-1`. Sie können es durch jede [unterstützte Region *Region-code*](https://docs.aws.amazon.com/general/latest/gr/appmesh.html) mit Ausnahme der `af-south-1` Regionen `me-south-1``ap-east-1`,`ap-southeast-3`,`eu-south-1`,`il-central-1`, und ersetzen. Sie können `1337` durch einen beliebigen Wert zwischen `0` und `2147483647` ersetzen.
```
sudo docker run --detach --env APPMESH_RESOURCE_ARN=mesh/apps/virtualNode/serviceB \
-u 1337 --network host 840364872350.dkr.ecr.region-code.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
+ Region `me-south-1`: Sie können `1337` durch einen beliebigen Wert zwischen `0` und `2147483647` ersetzen.
```
sudo docker run --detach --env APPMESH_RESOURCE_ARN=mesh/apps/virtualNode/serviceB \
-u 1337 --network host 772975370895.dkr.ecr.me-south-1.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
+ Region `ap-east-1`: Sie können `1337` durch einen beliebigen Wert zwischen `0` und `2147483647` ersetzen.
```
sudo docker run --detach --env APPMESH_RESOURCE_ARN=mesh/apps/virtualNode/serviceB \
-u 1337 --network host 856666278305.dkr.ecr.ap-east-1.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
**Anmerkung**
Für die `APPMESH_RESOURCE_ARN` Eigenschaft ist eine Version `1.15.0` oder eine neuere Version des Envoy-Images erforderlich. Weitere Informationen finden Sie unter [Bild des Gesandten](envoy.md).
**Wichtig**
Nur Version v1.9.0.0-prod oder höher wird für die Verwendung mit App Mesh unterstützt.
1. Wählen Sie im Folgenden `Show more` aus. Erstellen Sie eine Datei namens `envoy-networking.sh` mit dem folgenden Inhalt auf Ihrer Instance. Ersetzen Sie es *8000* durch den Port, den Ihr Anwendungscode für eingehenden Datenverkehr verwendet. Sie können den Wert für `APPMESH_IGNORE_UID` ändern, aber der Wert muss mit dem Wert übereinstimmen, den Sie im vorherigen Schritt angegeben haben, z. B. `1337`. Sie können bei Bedarf `APPMESH_EGRESS_IGNORED_IP` zusätzliche Adressen hinzufügen. Ändern Sie keine anderen Linien.
```
#!/bin/bash -e
#
# Start of configurable options
#
#APPMESH_START_ENABLED="0"
APPMESH_IGNORE_UID="1337"
APPMESH_APP_PORTS="8000"
APPMESH_ENVOY_EGRESS_PORT="15001"
APPMESH_ENVOY_INGRESS_PORT="15000"
APPMESH_EGRESS_IGNORED_IP="169.254.169.254,169.254.170.2"
# Enable routing on the application start.
[ -z "$APPMESH_START_ENABLED" ] && APPMESH_START_ENABLED="0"
# Enable IPv6.
[ -z "$APPMESH_ENABLE_IPV6" ] && APPMESH_ENABLE_IPV6="0"
# Egress traffic from the processess owned by the following UID/GID will be ignored.
if [ -z "$APPMESH_IGNORE_UID" ] && [ -z "$APPMESH_IGNORE_GID" ]; then
echo "Variables APPMESH_IGNORE_UID and/or APPMESH_IGNORE_GID must be set."
echo "Envoy must run under those IDs to be able to properly route it's egress traffic."
exit 1
fi
# Port numbers Application and Envoy are listening on.
if [ -z "$APPMESH_ENVOY_EGRESS_PORT" ]; then
echo "APPMESH_ENVOY_EGRESS_PORT must be defined to forward traffic from the application to the proxy."
exit 1
fi
# If an app port was specified, then we also need to enforce the proxies ingress port so we know where to forward traffic.
if [ ! -z "$APPMESH_APP_PORTS" ] && [ -z "$APPMESH_ENVOY_INGRESS_PORT" ]; then
echo "APPMESH_ENVOY_INGRESS_PORT must be defined to forward traffic from the APPMESH_APP_PORTS to the proxy."
exit 1
fi
# Comma separated list of ports for which egress traffic will be ignored, we always refuse to route SSH traffic.
if [ -z "$APPMESH_EGRESS_IGNORED_PORTS" ]; then
APPMESH_EGRESS_IGNORED_PORTS="22"
else
APPMESH_EGRESS_IGNORED_PORTS="$APPMESH_EGRESS_IGNORED_PORTS,22"
fi
#
# End of configurable options
#
function initialize() {
echo "=== Initializing ==="
if [ ! -z "$APPMESH_APP_PORTS" ]; then
iptables -t nat -N APPMESH_INGRESS
if [ "$APPMESH_ENABLE_IPV6" == "1" ]; then
ip6tables -t nat -N APPMESH_INGRESS
fi
fi
iptables -t nat -N APPMESH_EGRESS
if [ "$APPMESH_ENABLE_IPV6" == "1" ]; then
ip6tables -t nat -N APPMESH_EGRESS
fi
}
function enable_egress_routing() {
# Stuff to ignore
[ ! -z "$APPMESH_IGNORE_UID" ] && \
iptables -t nat -A APPMESH_EGRESS \
-m owner --uid-owner $APPMESH_IGNORE_UID \
-j RETURN
[ ! -z "$APPMESH_IGNORE_GID" ] && \
iptables -t nat -A APPMESH_EGRESS \
-m owner --gid-owner $APPMESH_IGNORE_GID \
-j RETURN
[ ! -z "$APPMESH_EGRESS_IGNORED_PORTS" ] && \
for IGNORED_PORT in $(echo "$APPMESH_EGRESS_IGNORED_PORTS" | tr "," "\n"); do
iptables -t nat -A APPMESH_EGRESS \
-p tcp \
-m multiport --dports "$IGNORED_PORT" \
-j RETURN
done
if [ "$APPMESH_ENABLE_IPV6" == "1" ]; then
# Stuff to ignore ipv6
[ ! -z "$APPMESH_IGNORE_UID" ] && \
ip6tables -t nat -A APPMESH_EGRESS \
-m owner --uid-owner $APPMESH_IGNORE_UID \
-j RETURN
[ ! -z "$APPMESH_IGNORE_GID" ] && \
ip6tables -t nat -A APPMESH_EGRESS \
-m owner --gid-owner $APPMESH_IGNORE_GID \
-j RETURN
[ ! -z "$APPMESH_EGRESS_IGNORED_PORTS" ] && \
for IGNORED_PORT in $(echo "$APPMESH_EGRESS_IGNORED_PORTS" | tr "," "\n"); do
ip6tables -t nat -A APPMESH_EGRESS \
-p tcp \
-m multiport --dports "$IGNORED_PORT" \
-j RETURN
done
fi
# The list can contain both IPv4 and IPv6 addresses. We will loop over this list
# to add every IPv4 address into `iptables` and every IPv6 address into `ip6tables`.
[ ! -z "$APPMESH_EGRESS_IGNORED_IP" ] && \
for IP_ADDR in $(echo "$APPMESH_EGRESS_IGNORED_IP" | tr "," "\n"); do
if [[ $IP_ADDR =~ .*:.* ]]
then
[ "$APPMESH_ENABLE_IPV6" == "1" ] && \
ip6tables -t nat -A APPMESH_EGRESS \
-p tcp \
-d "$IP_ADDR" \
-j RETURN
else
iptables -t nat -A APPMESH_EGRESS \
-p tcp \
-d "$IP_ADDR" \
-j RETURN
fi
done
# Redirect everything that is not ignored
iptables -t nat -A APPMESH_EGRESS \
-p tcp \
-j REDIRECT --to $APPMESH_ENVOY_EGRESS_PORT
# Apply APPMESH_EGRESS chain to non local traffic
iptables -t nat -A OUTPUT \
-p tcp \
-m addrtype ! --dst-type LOCAL \
-j APPMESH_EGRESS
if [ "$APPMESH_ENABLE_IPV6" == "1" ]; then
# Redirect everything that is not ignored ipv6
ip6tables -t nat -A APPMESH_EGRESS \
-p tcp \
-j REDIRECT --to $APPMESH_ENVOY_EGRESS_PORT
# Apply APPMESH_EGRESS chain to non local traffic ipv6
ip6tables -t nat -A OUTPUT \
-p tcp \
-m addrtype ! --dst-type LOCAL \
-j APPMESH_EGRESS
fi
}
function enable_ingress_redirect_routing() {
# Route everything arriving at the application port to Envoy
iptables -t nat -A APPMESH_INGRESS \
-p tcp \
-m multiport --dports "$APPMESH_APP_PORTS" \
-j REDIRECT --to-port "$APPMESH_ENVOY_INGRESS_PORT"
# Apply AppMesh ingress chain to everything non-local
iptables -t nat -A PREROUTING \
-p tcp \
-m addrtype ! --src-type LOCAL \
-j APPMESH_INGRESS
if [ "$APPMESH_ENABLE_IPV6" == "1" ]; then
# Route everything arriving at the application port to Envoy ipv6
ip6tables -t nat -A APPMESH_INGRESS \
-p tcp \
-m multiport --dports "$APPMESH_APP_PORTS" \
-j REDIRECT --to-port "$APPMESH_ENVOY_INGRESS_PORT"
# Apply AppMesh ingress chain to everything non-local ipv6
ip6tables -t nat -A PREROUTING \
-p tcp \
-m addrtype ! --src-type LOCAL \
-j APPMESH_INGRESS
fi
}
function enable_routing() {
echo "=== Enabling routing ==="
enable_egress_routing
if [ ! -z "$APPMESH_APP_PORTS" ]; then
enable_ingress_redirect_routing
fi
}
function disable_routing() {
echo "=== Disabling routing ==="
iptables -t nat -F APPMESH_INGRESS
iptables -t nat -F APPMESH_EGRESS
if [ "$APPMESH_ENABLE_IPV6" == "1" ]; then
ip6tables -t nat -F APPMESH_INGRESS
ip6tables -t nat -F APPMESH_EGRESS
fi
}
function dump_status() {
echo "=== iptables FORWARD table ==="
iptables -L -v -n
echo "=== iptables NAT table ==="
iptables -t nat -L -v -n
if [ "$APPMESH_ENABLE_IPV6" == "1" ]; then
echo "=== ip6tables FORWARD table ==="
ip6tables -L -v -n
echo "=== ip6tables NAT table ==="
ip6tables -t nat -L -v -n
fi
}
function clean_up() {
disable_routing
ruleNum=$(iptables -L PREROUTING -t nat --line-numbers | grep APPMESH_INGRESS | cut -d " " -f 1)
iptables -t nat -D PREROUTING $ruleNum
ruleNum=$(iptables -L OUTPUT -t nat --line-numbers | grep APPMESH_EGRESS | cut -d " " -f 1)
iptables -t nat -D OUTPUT $ruleNum
iptables -t nat -X APPMESH_INGRESS
iptables -t nat -X APPMESH_EGRESS
if [ "$APPMESH_ENABLE_IPV6" == "1" ]; then
ruleNum=$(ip6tables -L PREROUTING -t nat --line-numbers | grep APPMESH_INGRESS | cut -d " " -f 1)
ip6tables -t nat -D PREROUTING $ruleNum
ruleNum=$(ip6tables -L OUTPUT -t nat --line-numbers | grep APPMESH_EGRESS | cut -d " " -f 1)
ip6tables -t nat -D OUTPUT $ruleNum
ip6tables -t nat -X APPMESH_INGRESS
ip6tables -t nat -X APPMESH_EGRESS
fi
}
function main_loop() {
echo "=== Entering main loop ==="
while read -p '> ' cmd; do
case "$cmd" in
"quit")
clean_up
break
;;
"status")
dump_status
;;
"enable")
enable_routing
;;
"disable")
disable_routing
;;
*)
echo "Available commands: quit, status, enable, disable"
;;
esac
done
}
function print_config() {
echo "=== Input configuration ==="
env | grep APPMESH_ || true
}
print_config
initialize
if [ "$APPMESH_START_ENABLED" == "1" ]; then
enable_routing
fi
main_loop
```
1. Um `iptables`-Regeln für die Weiterleitung des Anwendungsdatenverkehrs an den Envoy-Proxy zu konfigurieren, führen Sie das Skript aus, das Sie im vorherigen Schritt erstellt haben.
```
sudo ./envoy-networking.sh
```
1. Starten Sie den Anwendungscodes Ihres virtuellen Knotens.
**Anmerkung**
Weitere Beispiele und Komplettlösungen für App Mesh finden Sie im App Mesh [Mesh-Beispiel-Repository](https://github.com/aws/aws-app-mesh-examples).
# Beispiele für App Mesh
**Wichtig**
Hinweis zum Ende des Supports: Am 30. September 2026 AWS wird der Support für eingestellt. AWS App Mesh Nach dem 30. September 2026 können Sie nicht mehr auf die AWS App Mesh Konsole oder die Ressourcen zugreifen. AWS App Mesh Weitere Informationen finden Sie in diesem Blogbeitrag [Migration von AWS App Mesh zu Amazon ECS Service Connect](https://aws.amazon.com/blogs/containers/migrating-from-aws-app-mesh-to-amazon-ecs-service-connect).
AWS App Mesh Im folgenden Repository finden Sie end-to-end exemplarische Vorgehensweisen mit Aktionen und Codebeispielen für die Integration mit verschiedenen AWS Diensten:
[Beispiele für App Mesh](https://github.com/aws/aws-app-mesh-examples)