Beispiele für die Verwendung der AWS CLI mit App Mesh - AWS Command Line Interface
Aktionen

Beispiele für die Verwendung der AWS CLI mit App Mesh

Die folgenden Codebeispiele zeigen, wie Sie Aktionen durchführen und gängige Szenarien implementieren, indem Sie die AWS Command Line Interface mit App Mesh nutzen.

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 Anleitungen zum Einrichten und Ausführen des Codes im Kontext finden.

Themen

Aktionen

Das folgende Codebeispiel zeigt, wie create-mesh verwendet wird.

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 im Benutzerhandbuch zu AWS App Mesh.

  • API-Details finden Sie unter CreateMesh in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie create-route verwendet wird.

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 von create-route-tcp.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 im Benutzerhandbuch zu AWS App Mesh.

  • API-Details finden Sie unter CreateRoute in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie create-virtual-gateway verwendet wird.

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 im Benutzerhandbuch zu AWS App Mesh.

Das folgende Codebeispiel zeigt, wie create-virtual-node verwendet wird.

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

Im folgenden Beispiel für create-virtual-node wird eine JSON-Eingabedatei verwendet, um einen virtuellen Knoten zu erstellen, der AWS Cloud Map für die Serviceerkennung 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 im Benutzerhandbuch zu AWS App Mesh.

Das folgende Codebeispiel zeigt, wie create-virtual-router verwendet wird.

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 im Benutzerhandbuch zu AWS App Mesh.

Das folgende Codebeispiel zeigt, wie create-virtual-service verwendet wird.

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 im Benutzerhandbuch zu 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 Virtuelle Services<https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_services.html> im Benutzerhandbuch zu AWS App Mesh.

Das folgende Codebeispiel zeigt, wie delete-mesh verwendet wird.

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 im Benutzerhandbuch zu AWS App Mesh.

  • API-Details finden Sie unter DeleteMesh in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie delete-route verwendet wird.

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 im Benutzerhandbuch zu AWS App Mesh.

  • API-Details finden Sie unter DeleteRoute in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie delete-virtual-node verwendet wird.

AWS CLI

So löschen Sie einen virtuellen Knoten

Im folgenden delete-virtual-node-Beispiel 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 im Benutzerhandbuch zu AWS App Mesh.

Das folgende Codebeispiel zeigt, wie delete-virtual-router verwendet wird.

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 im Benutzerhandbuch zu AWS App Mesh.

Das folgende Codebeispiel zeigt, wie delete-virtual-service verwendet wird.

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 im Benutzerhandbuch zu AWS App Mesh.

Das folgende Codebeispiel zeigt, wie describe-mesh verwendet wird.

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 im Benutzerhandbuch zu AWS App Mesh.

  • API-Details finden Sie unter DescribeMesh in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie describe-route verwendet wird.

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 im Benutzerhandbuch zu AWS App Mesh.

  • API-Details finden Sie unter DescribeRoute in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie describe-virtual-node verwendet wird.

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 im Benutzerhandbuch zu AWS App Mesh.

Das folgende Codebeispiel zeigt, wie describe-virtual-router verwendet wird.

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 im Benutzerhandbuch zu AWS App Mesh.

Das folgende Codebeispiel zeigt, wie describe-virtual-service verwendet wird.

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 im Benutzerhandbuch zu AWS App Mesh.

Das folgende Codebeispiel zeigt, wie list-meshes verwendet wird.

AWS CLI

So listen Sie Service Meshes auf

Im folgenden Beispiel für list-meshes werden alle Service Meshes in der aktuellen AWS-Region aufgelistet.

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 im Benutzerhandbuch zu AWS App Mesh.

  • API-Details finden Sie unter ListMeshes in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie list-routes verwendet wird.

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 im Benutzerhandbuch zu AWS App Mesh.

  • API-Details finden Sie unter ListRoutes in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie list-tags-for-resource verwendet wird.

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"
        }
    ]
}

Das folgende Codebeispiel zeigt, wie list-virtual-nodes verwendet wird.

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 im Benutzerhandbuch zu AWS App Mesh.

Das folgende Codebeispiel zeigt, wie list-virtual-routers verwendet wird.

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 im Benutzerhandbuch zu AWS App Mesh.

Das folgende Codebeispiel zeigt, wie list-virtual-services verwendet wird.

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 im Benutzerhandbuch zu AWS App Mesh.

Das folgende Codebeispiel zeigt, wie tag-resource verwendet wird.

AWS CLI

So markieren 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.

  • API-Details finden Sie unter TagResource in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie untag-resource verwendet wird.

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.

  • API-Details finden Sie unter UntagResource in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie update-mesh verwendet wird.

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 im Benutzerhandbuch zu AWS App Mesh.

  • API-Details finden Sie unter UpdateMesh in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie update-route verwendet wird.

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 im Benutzerhandbuch zu AWS App Mesh.

  • API-Details finden Sie unter UpdateRoute in der AWS CLI-Befehlsreferenz.

Das folgende Codebeispiel zeigt, wie update-virtual-node verwendet wird.

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 im Benutzerhandbuch zu AWS App Mesh.

Das folgende Codebeispiel zeigt, wie update-virtual-router verwendet wird.

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 im Benutzerhandbuch zu AWS App Mesh.

Das folgende Codebeispiel zeigt, wie update-virtual-service verwendet wird.

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 im Benutzerhandbuch zu AWS App Mesh.