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 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).