App Mesh Mesh-Beispiele mit AWS CLI - AWS Command Line Interface
Aktionen

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

Themen

Aktionen

Das folgende Codebeispiel zeigt die Verwendung voncreate-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 im Benutzerhandbuch zu AWS App Mesh.

  • Einzelheiten zur API finden Sie CreateMeshin der AWS CLI Befehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendungcreate-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 im Benutzerhandbuch zu AWS App Mesh.

  • Einzelheiten zur API finden Sie CreateRoutein der AWS CLI Befehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendungcreate-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 im Benutzerhandbuch zu AWS App Mesh.

Das folgende Codebeispiel zeigt die Verwendungcreate-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 im Benutzerhandbuch zu AWS App Mesh.

Das folgende Codebeispiel zeigt die Verwendungcreate-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 im Benutzerhandbuch zu AWS App Mesh.

Das folgende Codebeispiel zeigt die Verwendungcreate-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 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 Virtual Services< https://docs.aws.amazon.com/app-mesh/ latest/userguide/virtual _services.html> im App Mesh Mesh-Benutzerhandbuch AWS

Das folgende Codebeispiel zeigt die Verwendungdelete-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 im Benutzerhandbuch zu AWS App Mesh.

  • Einzelheiten zur API finden Sie DeleteMeshin der AWS CLI Befehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendungdelete-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 im Benutzerhandbuch zu AWS App Mesh.

  • Einzelheiten zur API finden Sie DeleteRoutein der AWS CLI Befehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendungdelete-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 im Benutzerhandbuch zu AWS App Mesh.

Das folgende Codebeispiel zeigt die Verwendungdelete-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 im Benutzerhandbuch zu AWS App Mesh.

Das folgende Codebeispiel zeigt die Verwendungdelete-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 im Benutzerhandbuch zu AWS App Mesh.

Das folgende Codebeispiel zeigt die Verwendungdescribe-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 im Benutzerhandbuch zu AWS App Mesh.

  • Einzelheiten zur API finden Sie DescribeMeshin der AWS CLI Befehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendungdescribe-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 im Benutzerhandbuch zu AWS App Mesh.

  • Einzelheiten zur API finden Sie DescribeRoutein der AWS CLI Befehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendungdescribe-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 im Benutzerhandbuch zu AWS App Mesh.

Das folgende Codebeispiel zeigt die Verwendungdescribe-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 im Benutzerhandbuch zu AWS App Mesh.

Das folgende Codebeispiel zeigt die Verwendungdescribe-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 im Benutzerhandbuch zu AWS App Mesh.

Das folgende Codebeispiel zeigt die Verwendunglist-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 im Benutzerhandbuch zu AWS App Mesh.

  • Einzelheiten zur API finden Sie ListMeshesin der AWS CLI Befehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendunglist-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 im Benutzerhandbuch zu AWS App Mesh.

  • Einzelheiten zur API finden Sie ListRoutesin der AWS CLI Befehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendunglist-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"
        }
    ]
}

Das folgende Codebeispiel zeigt die Verwendunglist-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 im Benutzerhandbuch zu AWS App Mesh.

  • Einzelheiten zur API finden Sie ListVirtualNodesin der AWS CLI Befehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendunglist-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 im Benutzerhandbuch zu AWS App Mesh.

Das folgende Codebeispiel zeigt die Verwendunglist-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 im Benutzerhandbuch zu AWS App Mesh.

Das folgende Codebeispiel zeigt die Verwendungtag-resource.

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.

  • Einzelheiten zur API finden Sie TagResourcein der AWS CLI Befehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendunguntag-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 UntagResourcein der AWS CLI Befehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendungupdate-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 im Benutzerhandbuch zu AWS App Mesh.

  • Einzelheiten zur API finden Sie UpdateMeshin der AWS CLI Befehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendungupdate-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 im Benutzerhandbuch zu AWS App Mesh.

  • Einzelheiten zur API finden Sie UpdateRoutein der AWS CLI Befehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendungupdate-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 im Benutzerhandbuch zu AWS App Mesh.

Das folgende Codebeispiel zeigt die Verwendungupdate-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 im Benutzerhandbuch zu AWS App Mesh.

Das folgende Codebeispiel zeigt die Verwendungupdate-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 im Benutzerhandbuch zu AWS App Mesh.