App Mesh Mesh-Beispiele mit AWS CLI - AWS SDKCode-Beispiele
Aktionen

Weitere AWS SDK Beispiele sind im Repo AWS Doc SDK Examples GitHub verfügbar.

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. Aktionen zeigen Ihnen zwar, wie Sie einzelne Servicefunktionen aufrufen, aber Sie können Aktionen in den zugehörigen Szenarien im Kontext sehen.

Jedes Beispiel enthält einen Link zum vollständigen Quellcode, in dem Sie Anweisungen zum Einrichten und Ausführen des Codes im Kontext finden.

Themen

Aktionen

Das folgende Codebeispiel zeigt die Verwendungcreate-mesh.

AWS CLI

Beispiel 1: Um ein neues Service Mesh zu erstellen

Das folgende create-mesh Beispiel erstellt ein Service Mesh.

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: Um ein neues Service Mesh mit mehreren Tags zu erstellen

Das folgende create-mesh Beispiel erstellt ein Service Mesh mit mehreren Tags.

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

  • APIEinzelheiten finden Sie CreateMeshin der AWS CLI Befehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendungcreate-route.

AWS CLI

Um eine neue RPC G-Route zu erstellen

Das folgende create-route Beispiel verwendet eine JSON Eingabedatei, um eine RPC G-Route zu erstellen. GRPCDatenverkehr mit Metadaten, die mit 123 beginnen, wird an einen virtuellen Knoten mit dem Namen serviceBgrpc weitergeleitet. Wenn beim Versuch RPCHTTP, mit dem Ziel der Route zu kommunizieren, bestimmte G-, 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"
    }
}

Um eine neue HTTP oder HTTP /2 Route zu erstellen

Das folgende create-route Beispiel verwendet eine JSON Eingabedatei, um eine HTTP /2-Route zu erstellen. Um eine HTTP Route zu erstellen, ersetzen Sie Http2Route durch httpRoute under spec. Der gesamte HTTP /2-Verkehr, der an ein URL Präfix adressiert ist, dessen Header-Wert mit 123 beginnt, wird an einen virtuellen Knoten mit dem Namen 2 weitergeleitet. serviceBhttp Wenn beim Versuch, mit dem Ziel der Route zu kommunizieren, bestimmte HTTP oder TCP Fehler auftreten, wird die Route dreimal wiederholt. Zwischen jedem erneuten Versuch 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"
    }
}

Um eine neue TCP Route zu erstellen

Im folgenden create-route Beispiel wird eine JSON Eingabedatei verwendet, um eine TCP Route zu erstellen. 75 Prozent des Datenverkehrs werden an einen virtuellen Knoten mit dem Namen weitergeleitetserviceBtcp, und 25 Prozent des Datenverkehrs werden an einen virtuellen Knoten namens serviceBv 2tcp 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 installiert 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 Routes im AWS App Mesh Mesh-Benutzerhandbuch.

  • APIEinzelheiten finden Sie CreateRoutein der AWS CLI Befehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendungcreate-virtual-gateway.

AWS CLI

Um ein neues virtuelles Gateway zu erstellen

Das folgende create-virtual-gateway Beispiel verwendet eine JSON Eingabedatei, um ein virtuelles Gateway mit einem Listener für die HTTP Verwendung von 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 Virtual Gateways im AWS App Mesh Mesh-Benutzerhandbuch.

Das folgende Codebeispiel zeigt die Verwendungcreate-virtual-node.

AWS CLI

Beispiel 1: Um einen neuen virtuellen Knoten zu erstellen, der DNS für die Erkennung verwendet wird

Das folgende create-virtual-node Beispiel verwendet eine JSON Eingabedatei, um einen virtuellen Knoten zu erstellen, der DNS für die Diensterkennung verwendet wird.

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

Das folgende Codebeispiel zeigt die Verwendungcreate-virtual-router.

AWS CLI

Um einen neuen virtuellen Router zu erstellen

Das folgende create-virtual-router Beispiel verwendet eine JSON Eingabedatei, um einen virtuellen Router mit einem Listener für die HTTP Verwendung von 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 AWS App Mesh Mesh-Benutzerhandbuch.

Das folgende Codebeispiel zeigt die Verwendungcreate-virtual-service.

AWS CLI

Beispiel 1: Um einen neuen virtuellen Dienst mit einem Anbieter für virtuelle Knoten zu erstellen

Im folgenden create-virtual-service Beispiel wird eine JSON Eingabedatei verwendet, um einen virtuellen Dienst 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 Virtual Node im AWS App Mesh Mesh-Benutzerhandbuch.

Beispiel 2: Um einen neuen virtuellen Dienst mit einem virtuellen Router-Anbieter zu erstellen

Das folgende create-virtual-service Beispiel verwendet eine JSON Eingabedatei, um einen virtuellen Dienst mit einem virtuellen Router-Anbieter 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

Um ein Service Mesh zu löschen

Im folgenden delete-mesh Beispiel 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 AWS App Mesh Mesh-Benutzerhandbuch.

  • APIEinzelheiten finden Sie DeleteMeshin der AWS CLI Befehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendungdelete-route.

AWS CLI

Um eine Route zu löschen

Im folgenden delete-route Beispiel 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 Routes im AWS App Mesh Mesh-Benutzerhandbuch.

  • APIEinzelheiten finden Sie DeleteRoutein der AWS CLI Befehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendungdelete-virtual-node.

AWS CLI

Um einen virtuellen Knoten zu löschen

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

Das folgende Codebeispiel zeigt die Verwendungdelete-virtual-router.

AWS CLI

Um einen virtuellen Router zu löschen

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

Das folgende Codebeispiel zeigt die Verwendungdelete-virtual-service.

AWS CLI

Um einen virtuellen Dienst zu löschen

Im folgenden delete-virtual-service Beispiel wird der angegebene virtuelle Dienst 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 Virtual Service im AWS App Mesh Mesh-Benutzerhandbuch.

Das folgende Codebeispiel zeigt die Verwendungdescribe-mesh.

AWS CLI

Um ein Service Mesh zu beschreiben

Das folgende describe-mesh Beispiel gibt Details zum angegebenen Service Mesh zurück.

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

  • APIEinzelheiten finden Sie DescribeMeshin der AWS CLI Befehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendungdescribe-route.

AWS CLI

Um eine Route zu beschreiben

Das folgende describe-route Beispiel gibt Details zur angegebenen Route zurück.

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

  • APIEinzelheiten finden Sie DescribeRoutein der AWS CLI Befehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendungdescribe-virtual-node.

AWS CLI

Um einen virtuellen Knoten zu beschreiben

Das folgende describe-virtual-node Beispiel gibt Details über den angegebenen virtuellen Knoten zurück.

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

Das folgende Codebeispiel zeigt die Verwendungdescribe-virtual-router.

AWS CLI

Um einen virtuellen Router zu beschreiben

Das folgende describe-virtual-router Beispiel gibt Details zum angegebenen virtuellen Router zurück.

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

Das folgende Codebeispiel zeigt die Verwendungdescribe-virtual-service.

AWS CLI

Um einen virtuellen Dienst zu beschreiben

Das folgende describe-virtual-service Beispiel gibt Details zum angegebenen virtuellen Dienst zurück.

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

Das folgende Codebeispiel zeigt die Verwendunglist-meshes.

AWS CLI

Um Service Meshes aufzulisten

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

  • APIEinzelheiten finden Sie ListMeshesin der AWS CLI Befehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendunglist-routes.

AWS CLI

Um Routen aufzulisten

Das folgende list-routes Beispiel listet alle Routen für den angegebenen virtuellen Router auf.

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

  • APIEinzelheiten finden Sie ListRoutesin der AWS CLI Befehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendunglist-tags-for-resource.

AWS CLI

Um Tags für eine Ressource aufzulisten

Das folgende list-tags-for-resource Beispiel listet alle Tags auf, 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

Um virtuelle Knoten aufzulisten

Das folgende list-virtual-nodes Beispiel listet alle virtuellen Knoten im angegebenen Service Mesh auf.

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

Das folgende Codebeispiel zeigt die Verwendunglist-virtual-routers.

AWS CLI

Um virtuelle Router aufzulisten

Das folgende list-virtual-routers Beispiel listet alle virtuellen Router im angegebenen Service Mesh auf.

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

Das folgende Codebeispiel zeigt die Verwendunglist-virtual-services.

AWS CLI

Um virtuelle Dienste aufzulisten

Das folgende list-virtual-services Beispiel listet alle virtuellen Dienste im angegebenen Service Mesh auf.

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

Das folgende Codebeispiel zeigt die Verwendungtag-resource.

AWS CLI

Um eine Ressource zu taggen

Im folgenden tag-resource Beispiel wird der angegebenen Ressource das Tag key1 mit value1 dem Wert 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.

  • APIEinzelheiten finden Sie TagResourceunter AWS CLI Befehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendunguntag-resource.

AWS CLI

Um die Markierung einer Ressource aufzuheben

Im folgenden untag-resource Beispiel 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.

  • APIEinzelheiten finden Sie UntagResourcein der AWS CLI Befehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendungupdate-mesh.

AWS CLI

Um ein Service Mesh zu aktualisieren

Im folgenden update-mesh Beispiel wird eine JSON Eingabedatei verwendet, um ein Service Mesh zu aktualisieren, sodass der gesamte externe Ausgangsverkehr 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 AWS App Mesh Mesh-Benutzerhandbuch.

  • APIEinzelheiten finden Sie UpdateMeshin der AWS CLI Befehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendungupdate-route.

AWS CLI

Um eine Route zu aktualisieren

Das folgende update-route Beispiel verwendet eine JSON Eingabedatei, 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 Routes im AWS App Mesh Mesh-Benutzerhandbuch.

  • APIEinzelheiten finden Sie UpdateRoutein der AWS CLI Befehlsreferenz.

Das folgende Codebeispiel zeigt die Verwendungupdate-virtual-node.

AWS CLI

Um einen virtuellen Knoten zu aktualisieren

Im folgenden update-virtual-node Beispiel wird eine JSON Eingabedatei verwendet, um einem virtuellen Knoten eine Integritätsprü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 AWS App Mesh Mesh-Benutzerhandbuch.

Das folgende Codebeispiel zeigt die Verwendungupdate-virtual-router.

AWS CLI

Um einen virtuellen Router zu aktualisieren

Im folgenden update-virtual-router Beispiel 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 AWS App Mesh Mesh-Benutzerhandbuch.

Das folgende Codebeispiel zeigt die Verwendungupdate-virtual-service.

AWS CLI

Um einen virtuellen Dienst zu aktualisieren

Im folgenden update-virtual-service Beispiel wird eine JSON Eingabedatei verwendet, um einen virtuellen Dienst so zu aktualisieren, dass er einen virtuellen Router-Anbieter 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 Virtual Services im AWS App Mesh Mesh-Benutzerhandbuch.