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.
# App Mesh Mesh-Beispiele mit AWS CLI
Die folgenden Codebeispiele zeigen Ihnen, wie Sie mithilfe von AWS Command Line Interface with App Mesh Aktionen ausführen und allgemeine Szenarien implementieren.
*Aktionen* sind Codeauszüge aus größeren Programmen und müssen im Kontext ausgeführt werden. Während Aktionen Ihnen zeigen, wie Sie einzelne Service-Funktionen aufrufen, können Sie Aktionen im Kontext der zugehörigen Szenarien anzeigen.
Jedes Beispiel enthält einen Link zum vollständigen Quellcode, wo Sie Anweisungen zum Einrichten und Ausführen des Codes im Kodex finden.
**Topics**
+ [Aktionen](#actions)
## Aktionen
### `create-mesh`
Das folgende Codebeispiel zeigt die Verwendung von`create-mesh`.
**AWS CLI**
**Beispiel 1: So erstellen Sie ein neues Service Mesh**
Im folgenden Beispiel für `create-mesh` wird ein Service Mesh erstellt.
```
aws appmesh create-mesh \
--mesh-name app1
```
Ausgabe:
```
{
"mesh":{
"meshName":"app1",
"metadata":{
"arn":"arn:aws:appmesh:us-east-1:123456789012:mesh/app1",
"createdAt":1563809909.282,
"lastUpdatedAt":1563809909.282,
"uid":"a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version":1
},
"spec":{},
"status":{
"status":"ACTIVE"
}
}
}
```
**Beispiel 2: So erstellen Sie ein neues Service Mesh mit mehreren Tags**
Im folgenden Beispiel für `create-mesh` wird ein Service Mesh mit mehreren Tags erstellt.
```
aws appmesh create-mesh \
--mesh-name app2 \
--tags key=key1,value=value1 key=key2,value=value2 key=key3,value=value3
```
Ausgabe:
```
{
"mesh":{
"meshName":"app2",
"metadata":{
"arn":"arn:aws:appmesh:us-east-1:123456789012:mesh/app2",
"createdAt":1563822121.877,
"lastUpdatedAt":1563822121.877,
"uid":"a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version":1
},
"spec":{},
"status":{
"status":"ACTIVE"
}
}
}
```
Weitere Informationen finden Sie unter [Service Meshes](https://docs.aws.amazon.com/app-mesh/latest/userguide/meshes.html) im *Benutzerhandbuch für AWS -App-Mesh*.
+ Einzelheiten zur API finden Sie [CreateMesh](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/create-mesh.html)in der *AWS CLI Befehlsreferenz*.
### `create-route`
Das folgende Codebeispiel zeigt die Verwendung`create-route`.
**AWS CLI**
**So erstellen Sie eine neue gRPC-Route**
Im folgenden Beispiel für `create-route` wird eine JSON-Eingabedatei für die Erstellung einer gRPC-Route verwendet. GRPC-Datenverkehr mit Metadaten, die mit 123 beginnen, wird an einen virtuellen Knoten namens serviceBgrpc weitergeleitet. Wenn beim Versuch, mit dem Ziel der Route zu kommunizieren, bestimmte gRPC-, HTTP- oder TCP-Fehler auftreten, wird die Route dreimal wiederholt. Zwischen jedem Wiederholungsversuch liegt eine Verzögerung von 15 Sekunden.
```
aws appmesh create-route \
--cli-input-json file://create-route-grpc.json
```
Inhalt von `create-route-grpc.json`:
```
{
"meshName" : "apps",
"routeName" : "grpcRoute",
"spec" : {
"grpcRoute" : {
"action" : {
"weightedTargets" : [
{
"virtualNode" : "serviceBgrpc",
"weight" : 100
}
]
},
"match" : {
"metadata" : [
{
"invert" : false,
"match" : {
"prefix" : "123"
},
"name" : "myMetadata"
}
],
"methodName" : "GetColor",
"serviceName" : "com.amazonaws.services.ColorService"
},
"retryPolicy" : {
"grpcRetryEvents" : [ "deadline-exceeded" ],
"httpRetryEvents" : [ "server-error", "gateway-error" ],
"maxRetries" : 3,
"perRetryTimeout" : {
"unit" : "s",
"value" : 15
},
"tcpRetryEvents" : [ "connection-error" ]
}
},
"priority" : 100
},
"virtualRouterName" : "serviceBgrpc"
}
```
Ausgabe:
```
{
"route": {
"meshName": "apps",
"metadata": {
"arn": "arn:aws:appmesh:us-west-2:123456789012:mesh/apps/virtualRouter/serviceBgrpc/route/grpcRoute",
"createdAt": 1572010806.008,
"lastUpdatedAt": 1572010806.008,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 1
},
"routeName": "grpcRoute",
"spec": {
"grpcRoute": {
"action": {
"weightedTargets": [
{
"virtualNode": "serviceBgrpc",
"weight": 100
}
]
},
"match": {
"metadata": [
{
"invert": false,
"match": {
"prefix": "123"
},
"name": "mymetadata"
}
],
"methodName": "GetColor",
"serviceName": "com.amazonaws.services.ColorService"
},
"retryPolicy": {
"grpcRetryEvents": [
"deadline-exceeded"
],
"httpRetryEvents": [
"server-error",
"gateway-error"
],
"maxRetries": 3,
"perRetryTimeout": {
"unit": "s",
"value": 15
},
"tcpRetryEvents": [
"connection-error"
]
}
},
"priority": 100
},
"status": {
"status": "ACTIVE"
},
"virtualRouterName": "serviceBgrpc"
}
}
```
**So erstellen Sie eine neue HTTP- oder HTTP/2-Route**
Im folgenden Beispiel für `create-route` wird eine JSON-Eingabedatei für die Erstellung einer HTTP/2-Route verwendet. Um eine HTTP-Route zu erstellen, ersetzen Sie http2Route unter „spec“ durch httpRoute. Der gesamte HTTP/2-Datenverkehr, der an ein URL-Präfix adressiert ist, dessen Header-Wert mit 123 beginnt, wird an einen virtuellen Knoten namens serviceBhttp2 weitergeleitet. Wenn beim Versuch, mit dem Ziel der Route zu kommunizieren, bestimmte HTTP- oder TCP-Fehler auftreten, wird die Route dreimal wiederholt. Zwischen jedem Wiederholungsversuch liegt eine Verzögerung von 15 Sekunden.
```
aws appmesh create-route \
--cli-input-json file://create-route-http2.json
```
Inhalt von `create-route-http2.json`:
```
{
"meshName": "apps",
"routeName": "http2Route",
"spec": {
"http2Route": {
"action": {
"weightedTargets": [
{
"virtualNode": "serviceBhttp2",
"weight": 100
}
]
},
"match": {
"headers": [
{
"invert": false,
"match": {
"prefix": "123"
},
"name": "clientRequestId"
}
],
"method": "POST",
"prefix": "/",
"scheme": "http"
},
"retryPolicy": {
"httpRetryEvents": [
"server-error",
"gateway-error"
],
"maxRetries": 3,
"perRetryTimeout": {
"unit": "s",
"value": 15
},
"tcpRetryEvents": [
"connection-error"
]
}
},
"priority": 200
},
"virtualRouterName": "serviceBhttp2"
}
```
Ausgabe:
```
{
"route": {
"meshName": "apps",
"metadata": {
"arn": "arn:aws:appmesh:us-west-2:123456789012:mesh/apps/virtualRouter/serviceBhttp2/route/http2Route",
"createdAt": 1572011008.352,
"lastUpdatedAt": 1572011008.352,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 1
},
"routeName": "http2Route",
"spec": {
"http2Route": {
"action": {
"weightedTargets": [
{
"virtualNode": "serviceBhttp2",
"weight": 100
}
]
},
"match": {
"headers": [
{
"invert": false,
"match": {
"prefix": "123"
},
"name": "clientRequestId"
}
],
"method": "POST",
"prefix": "/",
"scheme": "http"
},
"retryPolicy": {
"httpRetryEvents": [
"server-error",
"gateway-error"
],
"maxRetries": 3,
"perRetryTimeout": {
"unit": "s",
"value": 15
},
"tcpRetryEvents": [
"connection-error"
]
}
},
"priority": 200
},
"status": {
"status": "ACTIVE"
},
"virtualRouterName": "serviceBhttp2"
}
}
```
**So erstellen Sie eine neue TCP-Route**
Im folgenden Beispiel für `create-route` wird eine JSON-Eingabedatei verwendet, um eine TCP-Route zu erstellen. 75 Prozent des Datenverkehrs werden an einen virtuellen Knoten namens serviceBtcp weitergeleitet, und 25 Prozent des Datenverkehrs werden an einen virtuellen Knoten namens serviceBv2tcp weitergeleitet. Die Angabe unterschiedlicher Gewichtungen für verschiedene Ziele ist eine effektive Methode zur Bereitstellung einer neuen Version einer Anwendung. Sie können die Gewichtungen so anpassen, dass letztendlich 100 Prozent des gesamten Datenverkehrs an ein Ziel weitergeleitet werden, auf dem die neue Version einer Anwendung vorhanden ist.
```
aws appmesh create-route \
--cli-input-json file://create-route-tcp.json
```
Inhalt create-route-tcp von.json:
```
{
"meshName": "apps",
"routeName": "tcpRoute",
"spec": {
"priority": 300,
"tcpRoute": {
"action": {
"weightedTargets": [
{
"virtualNode": "serviceBtcp",
"weight": 75
},
{
"virtualNode": "serviceBv2tcp",
"weight": 25
}
]
}
}
},
"virtualRouterName": "serviceBtcp"
}
```
Ausgabe:
```
{
"route": {
"meshName": "apps",
"metadata": {
"arn": "arn:aws:appmesh:us-west-2:123456789012:mesh/apps/virtualRouter/serviceBtcp/route/tcpRoute",
"createdAt": 1572011436.26,
"lastUpdatedAt": 1572011436.26,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 1
},
"routeName": "tcpRoute",
"spec": {
"priority": 300,
"tcpRoute": {
"action": {
"weightedTargets": [
{
"virtualNode": "serviceBtcp",
"weight": 75
},
{
"virtualNode": "serviceBv2tcp",
"weight": 25
}
]
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualRouterName": "serviceBtcp"
}
}
```
Weitere Informationen finden Sie unter [Routen](https://docs.aws.amazon.com/app-mesh/latest/userguide/routes.html) im *Benutzerhandbuch für AWS App Mesh*.
+ Einzelheiten zur API finden Sie [CreateRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/create-route.html)in der *AWS CLI Befehlsreferenz.*
### `create-virtual-gateway`
Das folgende Codebeispiel zeigt die Verwendung`create-virtual-gateway`.
**AWS CLI**
**So erstellen Sie ein neues virtuelles Gateway**
Im folgenden Beispiel für `create-virtual-gateway` wird eine JSON-Eingabedatei verwendet, um ein virtuelles Gateway mit einem Listener für HTTP über Port 9080 zu erstellen.
```
aws appmesh create-virtual-gateway \
--mesh-name meshName \
--virtual-gateway-name virtualGatewayName \
--cli-input-json file://create-virtual-gateway.json
```
Inhalt von `create-virtual-gateway.json`:
```
{
"spec": {
"listeners": [
{
"portMapping": {
"port": 9080,
"protocol": "http"
}
}
]
}
}
```
Ausgabe:
```
{
"virtualGateway": {
"meshName": "meshName",
"metadata": {
"arn": "arn:aws:appmesh:us-west-2:123456789012:mesh/meshName/virtualGateway/virtualGatewayName",
"createdAt": "2022-04-06T10:42:42.015000-05:00",
"lastUpdatedAt": "2022-04-06T10:42:42.015000-05:00",
"meshOwner": "123456789012",
"resourceOwner": "123456789012",
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 1
},
"spec": {
"listeners": [
{
"portMapping": {
"port": 9080,
"protocol": "http"
}
}
]
},
"status": {
"status": "ACTIVE"
},
"virtualGatewayName": "virtualGatewayName"
}
}
```
Weitere Informationen finden Sie unter [Virtuelle Gateways](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_gateways.html) im * Benutzerhandbuch für AWS App Mesh*.
+ Einzelheiten zur API finden Sie [CreateVirtualGateway](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/create-virtual-gateway.html)in der *AWS CLI Befehlsreferenz*.
### `create-virtual-node`
Das folgende Codebeispiel zeigt die Verwendung`create-virtual-node`.
**AWS CLI**
**Beispiel 1: So erstellen Sie einen neuen virtuellen Knoten, der DNS für die Erkennung verwendet**
Im folgenden Beispiel für `create-virtual-node` wird eine JSON-Eingabedatei verwendet, um einen virtuellen Knoten zu erstellen, der DNS für die Serviceerkennung verwendet.
```
aws appmesh create-virtual-node \
--cli-input-json file://create-virtual-node-dns.json
```
Inhalt von `create-virtual-node-dns.json`:
```
{
"meshName": "app1",
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http"
}
}
],
"serviceDiscovery": {
"dns": {
"hostname": "serviceBv1.svc.cluster.local"
}
}
},
"virtualNodeName": "vnServiceBv1"
}
```
Ausgabe:
```
{
"virtualNode": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualNode/vnServiceBv1",
"createdAt": 1563810019.874,
"lastUpdatedAt": 1563810019.874,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 1
},
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http"
}
}
],
"serviceDiscovery": {
"dns": {
"hostname": "serviceBv1.svc.cluster.local"
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualNodeName": "vnServiceBv1"
}
}
```
**Beispiel 2: So erstellen Sie einen neuen virtuellen Knoten, der AWS Cloud Map für die Erkennung verwendet**
Das folgende `create-virtual-node` Beispiel verwendet eine JSON-Eingabedatei, um einen virtuellen Knoten zu erstellen, der AWS Cloud Map für die Diensterkennung verwendet.
```
aws appmesh create-virtual-node \
--cli-input-json file://create-virtual-node-cloud-map.json
```
Inhalt von `create-virtual-node-cloud-map.json`:
```
{
"meshName": "app1",
"spec": {
"backends": [
{
"virtualService": {
"virtualServiceName": "serviceA.svc.cluster.local"
}
}
],
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http"
}
}
],
"serviceDiscovery": {
"awsCloudMap": {
"attributes": [
{
"key": "Environment",
"value": "Testing"
}
],
"namespaceName": "namespace1",
"serviceName": "serviceA"
}
}
},
"virtualNodeName": "vnServiceA"
}
```
Ausgabe:
```
{
"virtualNode": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualNode/vnServiceA",
"createdAt": 1563810859.465,
"lastUpdatedAt": 1563810859.465,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 1
},
"spec": {
"backends": [
{
"virtualService": {
"virtualServiceName": "serviceA.svc.cluster.local"
}
}
],
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http"
}
}
],
"serviceDiscovery": {
"awsCloudMap": {
"attributes": [
{
"key": "Environment",
"value": "Testing"
}
],
"namespaceName": "namespace1",
"serviceName": "serviceA"
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualNodeName": "vnServiceA"
}
}
```
Weitere Informationen finden Sie unter [Virtuelle Knoten](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_nodes.html) im * Benutzerhandbuch für AWS App Mesh*.
+ Einzelheiten zur API finden Sie [CreateVirtualNode](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/create-virtual-node.html)unter *AWS CLI Befehlsreferenz*.
### `create-virtual-router`
Das folgende Codebeispiel zeigt die Verwendung`create-virtual-router`.
**AWS CLI**
**So erstellen Sie einen neuen virtuellen Router**
Im folgenden Beispiel für `create-virtual-router` wird eine JSON-Eingabedatei verwendet, um einen virtuellen Router mit einem Listener für HTTP über Port 80 zu erstellen.
```
aws appmesh create-virtual-router \
--cli-input-json file://create-virtual-router.json
```
Inhalt von `create-virtual-router.json`:
```
{
"meshName": "app1",
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http"
}
}
]
},
"virtualRouterName": "vrServiceB"
}
```
Ausgabe:
```
{
"virtualRouter": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualRouter/vrServiceB",
"createdAt": 1563810546.59,
"lastUpdatedAt": 1563810546.59,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 1
},
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http"
}
}
]
},
"status": {
"status": "ACTIVE"
},
"virtualRouterName": "vrServiceB"
}
}
```
Weitere Informationen finden Sie unter [Virtuelle Router](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_routers.html) im * Benutzerhandbuch für AWS App Mesh*.
+ Einzelheiten zur API finden Sie [CreateVirtualRouter](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/create-virtual-router.html)in der *AWS CLI Befehlsreferenz*.
### `create-virtual-service`
Das folgende Codebeispiel zeigt die Verwendung`create-virtual-service`.
**AWS CLI**
**Beispiel 1: So erstellen Sie einen neuen virtuellen Service mit einem Anbieter für virtuelle Knoten**
Im folgenden Beispiel für `create-virtual-service` wird eine JSON-Eingabedatei verwendet, um einen virtuellen Service mit einem Anbieter für virtuelle Knoten zu erstellen.
```
aws appmesh create-virtual-service \
--cli-input-json file://create-virtual-service-virtual-node.json
```
Inhalt von `create-virtual-service-virtual-node.json`:
```
{
"meshName": "app1",
"spec": {
"provider": {
"virtualNode": {
"virtualNodeName": "vnServiceA"
}
}
},
"virtualServiceName": "serviceA.svc.cluster.local"
}
```
Ausgabe:
```
{
"virtualService": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualService/serviceA.svc.cluster.local",
"createdAt": 1563810859.474,
"lastUpdatedAt": 1563810967.179,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 2
},
"spec": {
"provider": {
"virtualNode": {
"virtualNodeName": "vnServiceA"
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualServiceName": "serviceA.svc.cluster.local"
}
}
```
Weitere Informationen finden Sie unter [Virtueller Knoten](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_nodes.html) im * Benutzerhandbuch für AWS App Mesh*.
**Beispiel 2: So erstellen Sie einen neuen virtuellen Service mit einem Anbieter für virtuelle Router**
Im folgenden Beispiel für `create-virtual-service` wird eine JSON-Eingabedatei verwendet, um einen virtuellen Service mit einem Anbieter für virtuelle Router zu erstellen.
```
aws appmesh create-virtual-service \
--cli-input-json file://create-virtual-service-virtual-router.json
```
Inhalt von `create-virtual-service-virtual-router.json`:
```
{
"meshName": "app1",
"spec": {
"provider": {
"virtualRouter": {
"virtualRouterName": "vrServiceB"
}
}
},
"virtualServiceName": "serviceB.svc.cluster.local"
}
```
Ausgabe:
```
{
"virtualService": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualService/serviceB.svc.cluster.local",
"createdAt": 1563908363.999,
"lastUpdatedAt": 1563908363.999,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 1
},
"spec": {
"provider": {
"virtualRouter": {
"virtualRouterName": "vrServiceB"
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualServiceName": "serviceB.svc.cluster.local"
}
}
```
*Weitere Informationen finden Sie unter Virtual Services< https://docs.aws.amazon.com/app-mesh/ latest/userguide/virtual \$1services.html> im App Mesh Mesh-Benutzerhandbuch AWS *
+ *Einzelheiten zur API finden Sie in der Befehlsreferenz. [CreateVirtualService](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/create-virtual-service.html)AWS CLI *
### `delete-mesh`
Das folgende Codebeispiel zeigt die Verwendung`delete-mesh`.
**AWS CLI**
**So löschen Sie ein Service Mesh**
Im folgenden Beispiel für `delete-mesh` wird das angegebene Service Mesh gelöscht.
```
aws appmesh delete-mesh \
--mesh-name app1
```
Ausgabe:
```
{
"mesh": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1",
"createdAt": 1563809909.282,
"lastUpdatedAt": 1563824981.248,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 2
},
"spec": {
"egressFilter": {
"type": "ALLOW_ALL"
}
},
"status": {
"status": "DELETED"
}
}
}
```
Weitere Informationen finden Sie unter [Service Meshes](https://docs.aws.amazon.com/app-mesh/latest/userguide/meshes.html) im *Benutzerhandbuch für AWS -App-Mesh*.
+ Einzelheiten zur API finden Sie [DeleteMesh](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/delete-mesh.html)in der *AWS CLI Befehlsreferenz*.
### `delete-route`
Das folgende Codebeispiel zeigt die Verwendung`delete-route`.
**AWS CLI**
**So löschen Sie eine Route**
Im folgenden Beispiel für `delete-route` wird die angegebene Route gelöscht.
```
aws appmesh delete-route \
--mesh-name app1 \
--virtual-router-name vrServiceB \
--route-name toVnServiceB-weighted
```
Ausgabe:
```
{
"route": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualRouter/vrServiceB/route/toVnServiceB-weighted",
"createdAt": 1563811384.015,
"lastUpdatedAt": 1563823915.936,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 3
},
"routeName": "toVnServiceB-weighted",
"spec": {
"httpRoute": {
"action": {
"weightedTargets": [
{
"virtualNode": "vnServiceBv1",
"weight": 80
},
{
"virtualNode": "vnServiceBv2",
"weight": 20
}
]
},
"match": {
"prefix": "/"
}
}
},
"status": {
"status": "DELETED"
},
"virtualRouterName": "vrServiceB"
}
}
```
Weitere Informationen finden Sie unter [Routen](https://docs.aws.amazon.com/app-mesh/latest/userguide/routes.html) im *Benutzerhandbuch für AWS App Mesh*.
+ Einzelheiten zur API finden Sie [DeleteRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/delete-route.html)in der *AWS CLI Befehlsreferenz*.
### `delete-virtual-node`
Das folgende Codebeispiel zeigt die Verwendung`delete-virtual-node`.
**AWS CLI**
**So löschen Sie einen virtuellen Knoten**
Im folgenden Beispiel für `delete-virtual-node` wird der angegebene virtuelle Knoten gelöscht.
```
aws appmesh delete-virtual-node \
--mesh-name app1 \
--virtual-node-name vnServiceBv2
```
Ausgabe:
```
{
"virtualNode": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualNode/vnServiceBv2",
"createdAt": 1563810117.297,
"lastUpdatedAt": 1563824700.678,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 2
},
"spec": {
"backends": [],
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http"
}
}
],
"serviceDiscovery": {
"dns": {
"hostname": "serviceBv2.svc.cluster.local"
}
}
},
"status": {
"status": "DELETED"
},
"virtualNodeName": "vnServiceBv2"
}
}
```
Weitere Informationen finden Sie unter [Virtuelle Knoten](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_nodes.html) im * Benutzerhandbuch für AWS App Mesh*.
+ Einzelheiten zur API finden Sie [DeleteVirtualNode](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/delete-virtual-node.html)in der *AWS CLI Befehlsreferenz*.
### `delete-virtual-router`
Das folgende Codebeispiel zeigt die Verwendung`delete-virtual-router`.
**AWS CLI**
**So löschen Sie einen virtuellen Router**
Im folgenden Beispiel für `delete-virtual-router` wird der angegebene virtuelle Router gelöscht.
```
aws appmesh delete-virtual-router \
--mesh-name app1 \
--virtual-router-name vrServiceB
```
Ausgabe:
```
{
"virtualRouter": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualRouter/vrServiceB",
"createdAt": 1563810546.59,
"lastUpdatedAt": 1563824253.467,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 3
},
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http"
}
}
]
},
"status": {
"status": "DELETED"
},
"virtualRouterName": "vrServiceB"
}
}
```
Weitere Informationen finden Sie unter [Virtuelle Router](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_routers.html) im * Benutzerhandbuch für AWS App Mesh*.
+ Einzelheiten zur API finden Sie [DeleteVirtualRouter](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/delete-virtual-router.html)in der *AWS CLI Befehlsreferenz*.
### `delete-virtual-service`
Das folgende Codebeispiel zeigt die Verwendung`delete-virtual-service`.
**AWS CLI**
**So löschen Sie einen virtuellen Service**
Im folgenden Beispiel für `delete-virtual-service` wird der angegebene virtuelle Service gelöscht.
```
aws appmesh delete-virtual-service \
--mesh-name app1 \
--virtual-service-name serviceB.svc.cluster.local
```
Ausgabe:
```
{
"virtualService": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualService/serviceB.svc.cluster.local",
"createdAt": 1563908363.999,
"lastUpdatedAt": 1563913940.866,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 3
},
"spec": {},
"status": {
"status": "DELETED"
},
"virtualServiceName": "serviceB.svc.cluster.local"
}
}
```
Weitere Informationen finden Sie unter [Virtueller Service](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_services.html) im * Benutzerhandbuch für AWS App Mesh*.
+ Einzelheiten zur API finden Sie [DeleteVirtualService](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/delete-virtual-service.html)in der *AWS CLI Befehlsreferenz*.
### `describe-mesh`
Das folgende Codebeispiel zeigt die Verwendung`describe-mesh`.
**AWS CLI**
**So beschreiben Sie ein Service Mesh**
Im folgenden Beispiel für `describe-mesh` werden Details zum angegebenen Service Mesh zurückgegeben.
```
aws appmesh describe-mesh \
--mesh-name app1
```
Ausgabe:
```
{
"mesh": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1",
"createdAt": 1563809909.282,
"lastUpdatedAt": 1563809909.282,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 1
},
"spec": {},
"status": {
"status": "ACTIVE"
}
}
}
```
Weitere Informationen finden Sie unter [Service Meshes](https://docs.aws.amazon.com/app-mesh/latest/userguide/meshes.html) im *Benutzerhandbuch für AWS -App-Mesh*.
+ Einzelheiten zur API finden Sie [DescribeMesh](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/describe-mesh.html)in der *AWS CLI Befehlsreferenz*.
### `describe-route`
Das folgende Codebeispiel zeigt die Verwendung`describe-route`.
**AWS CLI**
**So beschreiben Sie eine Route**
Im folgenden Beispiel für `describe-route` werden Details zur angegebenen Route zurückgegeben.
```
aws appmesh describe-route \
--mesh-name app1 \
--virtual-router-name vrServiceB \
--route-name toVnServiceB-weighted
```
Ausgabe:
```
{
"route": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualRouter/vrServiceB/route/toVnServiceB-weighted",
"createdAt": 1563811384.015,
"lastUpdatedAt": 1563811384.015,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 1
},
"routeName": "toVnServiceB-weighted",
"spec": {
"httpRoute": {
"action": {
"weightedTargets": [
{
"virtualNode": "vnServiceBv1",
"weight": 90
},
{
"virtualNode": "vnServiceBv2",
"weight": 10
}
]
},
"match": {
"prefix": "/"
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualRouterName": "vrServiceB"
}
}
```
Weitere Informationen finden Sie unter [Routen](https://docs.aws.amazon.com/app-mesh/latest/userguide/routes.html) im *Benutzerhandbuch für AWS App Mesh*.
+ Einzelheiten zur API finden Sie [DescribeRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/describe-route.html)in der *AWS CLI Befehlsreferenz*.
### `describe-virtual-node`
Das folgende Codebeispiel zeigt die Verwendung`describe-virtual-node`.
**AWS CLI**
**So beschreiben Sie einen virtuellen Knoten**
Im folgenden Beispiel für `describe-virtual-node` werden Details zum angegebenen virtuellen Knoten zurückgegeben.
```
aws appmesh describe-virtual-node \
--mesh-name app1 \
--virtual-node-name vnServiceBv1
```
Ausgabe:
```
{
"virtualNode": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualNode/vnServiceBv1",
"createdAt": 1563810019.874,
"lastUpdatedAt": 1563810019.874,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 1
},
"spec": {
"backends": [],
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http"
}
}
],
"serviceDiscovery": {
"dns": {
"hostname": "serviceBv1.svc.cluster.local"
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualNodeName": "vnServiceBv1"
}
}
```
Weitere Informationen finden Sie unter [Virtuelle Knoten](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_nodes.html) im * Benutzerhandbuch für AWS App Mesh*.
+ Einzelheiten zur API finden Sie [DescribeVirtualNode](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/describe-virtual-node.html)in der *AWS CLI Befehlsreferenz*.
### `describe-virtual-router`
Das folgende Codebeispiel zeigt die Verwendung`describe-virtual-router`.
**AWS CLI**
**So beschreiben Sie einen virtuellen Router**
Im folgenden Beispiel für `describe-virtual-router` werden Details zum angegebenen virtuellen Router zurückgegeben.
```
aws appmesh describe-virtual-router \
--mesh-name app1 \
--virtual-router-name vrServiceB
```
Ausgabe:
```
{
"virtualRouter": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualRouter/vrServiceB",
"createdAt": 1563810546.59,
"lastUpdatedAt": 1563810546.59,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 1
},
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http"
}
}
]
},
"status": {
"status": "ACTIVE"
},
"virtualRouterName": "vrServiceB"
}
}
```
Weitere Informationen finden Sie unter [Virtuelle Router](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_routers.html) im * Benutzerhandbuch für AWS App Mesh*.
+ Einzelheiten zur API finden Sie [DescribeVirtualRouter](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/describe-virtual-router.html)in der *AWS CLI Befehlsreferenz*.
### `describe-virtual-service`
Das folgende Codebeispiel zeigt die Verwendung`describe-virtual-service`.
**AWS CLI**
**So beschreiben Sie einen virtuellen Service**
Im folgenden Beispiel für `describe-virtual-service` werden Details zum angegebenen virtuellen Service zurückgegeben.
```
aws appmesh describe-virtual-service \
--mesh-name app1 \
--virtual-service-name serviceB.svc.cluster.local
```
Ausgabe:
```
{
"virtualService": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualService/serviceB.svc.cluster.local",
"createdAt": 1563908363.999,
"lastUpdatedAt": 1563908363.999,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 1
},
"spec": {
"provider": {
"virtualRouter": {
"virtualRouterName": "vrServiceB"
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualServiceName": "serviceB.svc.cluster.local"
}
}
```
Weitere Informationen finden Sie unter [Virtuelle Services](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_services.html) im * Benutzerhandbuch für AWS App Mesh*.
+ Einzelheiten zur API finden Sie [DescribeVirtualService](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/describe-virtual-service.html)in der *AWS CLI Befehlsreferenz*.
### `list-meshes`
Das folgende Codebeispiel zeigt die Verwendung`list-meshes`.
**AWS CLI**
**So listen Sie Service Meshes auf**
Das folgende `list-meshes` Beispiel listet alle Service Meshes in der aktuellen AWS Region auf.
```
aws appmesh list-meshes
```
Ausgabe:
```
{
"meshes": [
{
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1",
"meshName": "app1"
}
]
}
```
Weitere Informationen finden Sie unter [Service Meshes](https://docs.aws.amazon.com/app-mesh/latest/userguide/meshes.html) im *Benutzerhandbuch für AWS -App-Mesh*.
+ Einzelheiten zur API finden Sie [ListMeshes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/list-meshes.html)in der *AWS CLI Befehlsreferenz.*
### `list-routes`
Das folgende Codebeispiel zeigt die Verwendung`list-routes`.
**AWS CLI**
**So listen Sie Routen auf**
Im folgenden Beispiel für `list-routes` werden alle Routen für den angegebenen virtuellen Router aufgelistet.
```
aws appmesh list-routes \
--mesh-name app1 \
--virtual-router-name vrServiceB
```
Ausgabe:
```
{
"routes": [
{
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualRouter/vrServiceB/route/toVnServiceB",
"meshName": "app1",
"routeName": "toVnServiceB-weighted",
"virtualRouterName": "vrServiceB"
}
]
}
```
Weitere Informationen finden Sie unter [Routen](https://docs.aws.amazon.com/app-mesh/latest/userguide/routes.html) im *Benutzerhandbuch für AWS App Mesh*.
+ Einzelheiten zur API finden Sie [ListRoutes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/list-routes.html)in der *AWS CLI Befehlsreferenz*.
### `list-tags-for-resource`
Das folgende Codebeispiel zeigt die Verwendung`list-tags-for-resource`.
**AWS CLI**
**So listen Sie Tags für eine Ressource auf**
Im folgenden Beispiel für `list-tags-for-resource` werden alle Tags aufgelistet, die der angegebenen Ressource zugewiesen sind.
```
aws appmesh list-tags-for-resource \
--resource-arn arn:aws:appmesh:us-east-1:123456789012:mesh/app1
```
Ausgabe:
```
{
"tags": [
{
"key": "key1",
"value": "value1"
},
{
"key": "key2",
"value": "value2"
},
{
"key": "key3",
"value": "value3"
}
]
}
```
+ Einzelheiten zur API finden Sie [ListTagsForResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/list-tags-for-resource.html)in der *AWS CLI Befehlsreferenz*.
### `list-virtual-nodes`
Das folgende Codebeispiel zeigt die Verwendung`list-virtual-nodes`.
**AWS CLI**
**So listen Sie virtuelle Knoten auf**
Im folgenden Beispiel für `list-virtual-nodes` werden alle virtuellen Knoten im angegebenen Service Mesh aufgelistet.
```
aws appmesh list-virtual-nodes \
--mesh-name app1
```
Ausgabe:
```
{
"virtualNodes": [
{
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualNode/vnServiceBv1",
"meshName": "app1",
"virtualNodeName": "vnServiceBv1"
},
{
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualNode/vnServiceBv2",
"meshName": "app1",
"virtualNodeName": "vnServiceBv2"
}
]
}
```
Weitere Informationen finden Sie unter [Virtuelle Knoten](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_nodes.html) im * Benutzerhandbuch für AWS App Mesh*.
+ Einzelheiten zur API finden Sie [ListVirtualNodes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/list-virtual-nodes.html)in der *AWS CLI Befehlsreferenz*.
### `list-virtual-routers`
Das folgende Codebeispiel zeigt die Verwendung`list-virtual-routers`.
**AWS CLI**
**So listen Sie virtuelle Router auf**
Im folgenden Beispiel für `list-virtual-routers` werden alle virtuellen Router im angegebenen Service Mesh aufgelistet.
```
aws appmesh list-virtual-routers \
--mesh-name app1
```
Ausgabe:
```
{
"virtualRouters": [
{
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualRouter/vrServiceB",
"meshName": "app1",
"virtualRouterName": "vrServiceB"
}
]
}
```
Weitere Informationen finden Sie unter [Virtuelle Router](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_routers.html) im * Benutzerhandbuch für AWS App Mesh*.
+ Einzelheiten zur API finden Sie [ListVirtualRouters](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/list-virtual-routers.html)in der *AWS CLI Befehlsreferenz*.
### `list-virtual-services`
Das folgende Codebeispiel zeigt die Verwendung`list-virtual-services`.
**AWS CLI**
**So listen Sie virtuelle Services auf**
Im folgenden Beispiel für `list-virtual-services` werden alle virtuellen Services im angegebenen Service Mesh aufgelistet.
```
aws appmesh list-virtual-services \
--mesh-name app1
```
Ausgabe:
```
{
"virtualServices": [
{
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualService/serviceA.svc.cluster.local",
"meshName": "app1",
"virtualServiceName": "serviceA.svc.cluster.local"
},
{
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualService/serviceB.svc.cluster.local",
"meshName": "app1",
"virtualServiceName": "serviceB.svc.cluster.local"
}
]
}
```
Weitere Informationen finden Sie unter [Virtuelle Services](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_services.html) im * Benutzerhandbuch für AWS App Mesh*.
+ Einzelheiten zur API finden Sie [ListVirtualServices](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/list-virtual-services.html)in der *AWS CLI Befehlsreferenz*.
### `tag-resource`
Das folgende Codebeispiel zeigt die Verwendung`tag-resource`.
**AWS CLI**
**So taggen Sie eine Ressource**
Im folgenden Beispiel für `tag-resource` wird der angegebenen Ressource das Tag `key1` mit dem Wert `value1` hinzugefügt.
```
aws appmesh tag-resource \
--resource-arn arn:aws:appmesh:us-east-1:123456789012:mesh/app1 \
--tags key=key1,value=value1
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben.
+ Einzelheiten zur API finden Sie [TagResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/tag-resource.html)in der *AWS CLI Befehlsreferenz*.
### `untag-resource`
Das folgende Codebeispiel zeigt die Verwendung`untag-resource`.
**AWS CLI**
**So entfernen Sie Tags von einer Ressource**
Im folgenden Beispiel für `untag-resource` wird ein Tag mit dem Schlüssel `key1` aus der angegebenen Ressource entfernt.
```
aws appmesh untag-resource \
--resource-arn arn:aws:appmesh:us-east-1:123456789012:mesh/app1 \
--tag-keys key1
```
Mit diesem Befehl wird keine Ausgabe zurückgegeben.
+ Einzelheiten zur API finden Sie [UntagResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/untag-resource.html)in der *AWS CLI Befehlsreferenz*.
### `update-mesh`
Das folgende Codebeispiel zeigt die Verwendung`update-mesh`.
**AWS CLI**
**So aktualisieren Sie ein Service Mesh**
Im folgenden Beispiel für `update-mesh` wird eine JSON-Eingabedatei verwendet, um ein Service Mesh zu aktualisieren, sodass der gesamte externe Ausgangsdatenverkehr unverändert über den Envoy-Proxy weitergeleitet werden kann.
```
aws appmesh update-mesh \
--cli-input-json file://update-mesh.json
```
Inhalt von `update-mesh.json`:
```
{
"meshName": "app1",
"spec": {
"egressFilter": {
"type": "ALLOW_ALL"
}
}
}
```
Ausgabe:
```
{
"mesh": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1",
"createdAt": 1563809909.282,
"lastUpdatedAt": 1563812829.687,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 2
},
"spec": {
"egressFilter": {
"type": "ALLOW_ALL"
}
},
"status": {
"status": "ACTIVE"
}
}
}
```
Weitere Informationen finden Sie unter [Service Meshes](https://docs.aws.amazon.com/app-mesh/latest/userguide/meshes.html) im *Benutzerhandbuch für AWS -App-Mesh*.
+ Einzelheiten zur API finden Sie [UpdateMesh](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/update-mesh.html)in der *AWS CLI Befehlsreferenz*.
### `update-route`
Das folgende Codebeispiel zeigt die Verwendung`update-route`.
**AWS CLI**
**So aktualisieren Sie eine Route**
Im folgenden Beispiel für `update-route` wird eine JSON-Eingabedatei verwendet, um die Gewichtungen für eine Route zu aktualisieren.
```
aws appmesh update-route \
--cli-input-json file://update-route-weighted.json
```
Inhalt von `update-route-weighted.json`:
```
{
"meshName": "app1",
"routeName": "toVnServiceB-weighted",
"spec": {
"httpRoute": {
"action": {
"weightedTargets": [
{
"virtualNode": "vnServiceBv1",
"weight": 80
},
{
"virtualNode": "vnServiceBv2",
"weight": 20
}
]
},
"match": {
"prefix": "/"
}
}
},
"virtualRouterName": "vrServiceB"
}
```
Ausgabe:
```
{
"route": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualRouter/vrServiceB/route/toVnServiceB-weighted",
"createdAt": 1563811384.015,
"lastUpdatedAt": 1563819600.022,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 2
},
"routeName": "toVnServiceB-weighted",
"spec": {
"httpRoute": {
"action": {
"weightedTargets": [
{
"virtualNode": "vnServiceBv1",
"weight": 80
},
{
"virtualNode": "vnServiceBv2",
"weight": 20
}
]
},
"match": {
"prefix": "/"
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualRouterName": "vrServiceB"
}
}
```
Weitere Informationen finden Sie unter [Routen](https://docs.aws.amazon.com/app-mesh/latest/userguide/routes.html) im *Benutzerhandbuch für AWS App Mesh*.
+ Einzelheiten zur API finden Sie [UpdateRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/update-route.html)in der *AWS CLI Befehlsreferenz*.
### `update-virtual-node`
Das folgende Codebeispiel zeigt die Verwendung`update-virtual-node`.
**AWS CLI**
**So aktualisieren Sie einen virtuellen Knoten**
Im folgenden Beispiel für `update-virtual-node` wird eine JSON-Eingabedatei verwendet, um einem virtuellen Knoten eine Zustandsprüfung hinzuzufügen.
```
aws appmesh update-virtual-node \
--cli-input-json file://update-virtual-node.json
```
Inhalt von `update-virtual-node.json`:
```
{
"clientToken": "500",
"meshName": "app1",
"spec": {
"listeners": [
{
"healthCheck": {
"healthyThreshold": 5,
"intervalMillis": 10000,
"path": "/",
"port": 80,
"protocol": "http",
"timeoutMillis": 3000,
"unhealthyThreshold": 3
},
"portMapping": {
"port": 80,
"protocol": "http"
}
}
],
"serviceDiscovery": {
"dns": {
"hostname": "serviceBv1.svc.cluster.local"
}
}
},
"virtualNodeName": "vnServiceBv1"
}
```
Ausgabe:
```
{
"virtualNode": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualNode/vnServiceBv1",
"createdAt": 1563810019.874,
"lastUpdatedAt": 1563819234.825,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 2
},
"spec": {
"listeners": [
{
"healthCheck": {
"healthyThreshold": 5,
"intervalMillis": 10000,
"path": "/",
"port": 80,
"protocol": "http",
"timeoutMillis": 3000,
"unhealthyThreshold": 3
},
"portMapping": {
"port": 80,
"protocol": "http"
}
}
],
"serviceDiscovery": {
"dns": {
"hostname": "serviceBv1.svc.cluster.local"
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualNodeName": "vnServiceBv1"
}
}
```
Weitere Informationen finden Sie unter [Virtuelle Knoten](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_nodes.html) im * Benutzerhandbuch für AWS App Mesh*.
+ Einzelheiten zur API finden Sie [UpdateVirtualNode](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/update-virtual-node.html)in der *AWS CLI Befehlsreferenz*.
### `update-virtual-router`
Das folgende Codebeispiel zeigt die Verwendung`update-virtual-router`.
**AWS CLI**
**So aktualisieren Sie einen virtuellen Router**
Im folgenden Beispiel für `update-virtual-router` wird eine JSON-Eingabedatei verwendet, um den Listener-Port eines virtuellen Routers zu aktualisieren.
```
aws appmesh update-virtual-router \
--cli-input-json file://update-virtual-router.json
```
Inhalt von `update-virtual-router.json`:
```
{
"meshName": "app1",
"spec": {
"listeners": [
{
"portMapping": {
"port": 8080,
"protocol": "http"
}
}
]
},
"virtualRouterName": "vrServiceB"
}
```
Ausgabe:
```
{
"virtualRouter": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualRouter/vrServiceB",
"createdAt": 1563810546.59,
"lastUpdatedAt": 1563819431.352,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 2
},
"spec": {
"listeners": [
{
"portMapping": {
"port": 8080,
"protocol": "http"
}
}
]
},
"status": {
"status": "ACTIVE"
},
"virtualRouterName": "vrServiceB"
}
}
```
Weitere Informationen finden Sie unter [Virtuelle Router](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_routers.html) im * Benutzerhandbuch für AWS App Mesh*.
+ Einzelheiten zur API finden Sie [UpdateVirtualRouter](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/update-virtual-router.html)in der *AWS CLI Befehlsreferenz*.
### `update-virtual-service`
Das folgende Codebeispiel zeigt die Verwendung`update-virtual-service`.
**AWS CLI**
**So aktualisieren Sie einen virtuellen Service**
Im folgenden Beispiel für `update-virtual-service` wird eine JSON-Eingabedatei verwendet, um einen virtuellen Service so zu aktualisieren, dass er einen Anbieter für virtuelle Router verwendet.
```
aws appmesh update-virtual-service \
--cli-input-json file://update-virtual-service.json
```
Inhalt von `update-virtual-service.json`:
```
{
"meshName": "app1",
"spec": {
"provider": {
"virtualRouter": {
"virtualRouterName": "vrServiceA"
}
}
},
"virtualServiceName": "serviceA.svc.cluster.local"
}
```
Ausgabe:
```
{
"virtualService": {
"meshName": "app1",
"metadata": {
"arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualService/serviceA.svc.cluster.local",
"createdAt": 1563810859.474,
"lastUpdatedAt": 1563820257.411,
"uid": "a1b2c3d4-5678-90ab-cdef-11111EXAMPLE",
"version": 3
},
"spec": {
"provider": {
"virtualRouter": {
"virtualRouterName": "vrServiceA"
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualServiceName": "serviceA.svc.cluster.local"
}
}
```
Weitere Informationen finden Sie unter [Virtuelle Services](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_services.html) im * Benutzerhandbuch für AWS App Mesh*.
+ Einzelheiten zur API finden Sie [UpdateVirtualService](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/update-virtual-service.html)in der *AWS CLI Befehlsreferenz*.