Esempi di App Mesh utilizzando AWS CLI - AWS Command Line Interface
Azioni

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Esempi di App Mesh utilizzando AWS CLI

I seguenti esempi di codice mostrano come eseguire azioni e implementare scenari comuni utilizzando AWS Command Line Interface with App Mesh.

Le operazioni sono estratti di codice da programmi più grandi e devono essere eseguite nel contesto. Mentre le azioni mostrano come richiamare le singole funzioni di servizio, è possibile visualizzare le azioni nel loro contesto negli scenari correlati.

Ogni esempio include un collegamento al codice sorgente completo, in cui è possibile trovare istruzioni su come configurare ed eseguire il codice nel contesto.

Argomenti

Azioni

Il seguente esempio di codice mostra come utilizzarecreate-mesh.

AWS CLI

Esempio 1: Per creare una nuova rete di servizi

L'create-meshesempio seguente crea una service mesh.

aws appmesh create-mesh \
    --mesh-name app1

Output:

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

Esempio 2: creare una nuova service mesh con più tag

L'create-meshesempio seguente crea una service mesh con più tag.

aws appmesh create-mesh \
    --mesh-name app2 \
    --tags key=key1,value=value1 key=key2,value=value2 key=key3,value=value3

Output:

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

Per ulteriori informazioni, consulta Service Meshes nella AWS App Mesh User Guide.

  • Per API i dettagli, vedere CreateMeshin AWS CLI Command Reference.

Il seguente esempio di codice mostra come utilizzarecreate-route.

AWS CLI

Per creare una nuova RPC rotta g

L'create-routeesempio seguente utilizza un file JSON di input per creare un RPC percorso g. GRPCil traffico con metadati che iniziano con 123 viene indirizzato a un nodo virtuale denominato. serviceBgrpc Se si verificano TCP errori specifici g RPCHTTP, o durante il tentativo di comunicare con la destinazione della route, la route viene ritentata tre volte. C'è un ritardo di 15 secondi tra ogni tentativo.

aws appmesh create-route \
    --cli-input-json file://create-route-grpc.json

Contenuto di 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"
}

Output:

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

Per creare una nuova rotta HTTP o HTTP /2

L'create-routeesempio seguente utilizza un file JSON di input per creare una route HTTP /2. Per creare una HTTP rotta, sostituisci Http2Route con httpRoute under spec. Tutto il traffico HTTP /2 indirizzato a qualsiasi URL prefisso con un valore di intestazione che inizia con 123 viene indirizzato a un nodo virtuale denominato 2. serviceBhttp Se si verificano errori specifici HTTP o si TCP verificano errori nel tentativo di comunicare con la destinazione della route, la route viene ritentata tre volte. C'è un ritardo di 15 secondi tra ogni tentativo.

aws appmesh create-route \
    --cli-input-json file://create-route-http2.json

Contenuto di 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"
}

Output:

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

Per creare un nuovo percorso TCP

L'create-routeesempio seguente utilizza un file JSON di input per creare un TCP percorso. Il 75 percento del traffico viene indirizzato a un nodo virtuale denominato serviceBtcp e il 25 percento del traffico viene instradato a un nodo virtuale denominato serviceBv 2tcp. Specificare ponderazioni diverse per obiettivi diversi è un modo efficace per eseguire la distribuzione di una nuova versione di un'applicazione. È possibile modificare i pesi in modo che alla fine il 100% di tutto il traffico venga indirizzato a una destinazione che dispone della nuova versione di un'applicazione.

aws appmesh create-route \
    --cli-input-json file://create-route-tcp.json

Contenuto di.json create-route-tcp:

{
    "meshName": "apps",
    "routeName": "tcpRoute",
    "spec": {
        "priority": 300,
        "tcpRoute": {
            "action": {
                "weightedTargets": [
                    {
                        "virtualNode": "serviceBtcp",
                        "weight": 75
                    },
                    {
                        "virtualNode": "serviceBv2tcp",
                        "weight": 25
                    }
                ]
            }
        }
    },
    "virtualRouterName": "serviceBtcp"
}

Output:

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

Per ulteriori informazioni, consulta Routes nella AWS App Mesh User Guide.

  • Per API i dettagli, vedere CreateRoutein AWS CLI Command Reference.

Il seguente esempio di codice mostra come utilizzarecreate-virtual-gateway.

AWS CLI

Per creare un nuovo gateway virtuale

L'create-virtual-gatewayesempio seguente utilizza un file JSON di input per creare un gateway virtuale con un listener per HTTP l'utilizzo della porta 9080.

aws appmesh create-virtual-gateway \
    --mesh-name meshName \
    --virtual-gateway-name virtualGatewayName \
    --cli-input-json file://create-virtual-gateway.json

Contenuto di create-virtual-gateway.json.

{
    "spec": {
      "listeners": [
        {
          "portMapping": {
            "port": 9080,
            "protocol": "http"
          }
        }
      ]
    }
}

Output:

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

Per ulteriori informazioni, consulta Virtual Gateways nella AWS App Mesh User Guide.

Il seguente esempio di codice mostra come utilizzarecreate-virtual-node.

AWS CLI

Esempio 1: per creare un nuovo nodo virtuale da utilizzare DNS per il rilevamento

L'create-virtual-nodeesempio seguente utilizza un file JSON di input per creare un nodo virtuale utilizzato DNS per l'individuazione dei servizi.

aws appmesh create-virtual-node \
    --cli-input-json file://create-virtual-node-dns.json

Contenuto di create-virtual-node-dns.json.

{
    "meshName": "app1",
    "spec": {
        "listeners": [
            {
                "portMapping": {
                    "port": 80,
                    "protocol": "http"
                }
            }
        ],
        "serviceDiscovery": {
            "dns": {
                "hostname": "serviceBv1.svc.cluster.local"
            }
        }
    },
    "virtualNodeName": "vnServiceBv1"
}

Output:

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

Esempio 2: creare un nuovo nodo virtuale che utilizza AWS Cloud Map per il rilevamento

L'create-virtual-nodeesempio seguente utilizza un file JSON di input per creare un nodo virtuale che utilizza AWS Cloud Map per l'individuazione dei servizi.

aws appmesh create-virtual-node \
    --cli-input-json file://create-virtual-node-cloud-map.json

Contenuto di 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"
}

Output:

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

Per ulteriori informazioni, consulta Virtual Nodes nella AWS App Mesh User Guide.

Il seguente esempio di codice mostra come utilizzarecreate-virtual-router.

AWS CLI

Per creare un nuovo router virtuale

L'create-virtual-routeresempio seguente utilizza un file JSON di input per creare un router virtuale con un listener per HTTP l'utilizzo della porta 80.

aws appmesh create-virtual-router \
    --cli-input-json file://create-virtual-router.json

Contenuto di create-virtual-router.json.

{
    "meshName": "app1",
    "spec": {
        "listeners": [
            {
                "portMapping": {
                    "port": 80,
                    "protocol": "http"
                }
            }
        ]
    },
    "virtualRouterName": "vrServiceB"
}

Output:

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

Per ulteriori informazioni, consulta Virtual Router nella AWS App Mesh User Guide.

Il seguente esempio di codice mostra come utilizzarecreate-virtual-service.

AWS CLI

Esempio 1: creare un nuovo servizio virtuale con un provider di nodi virtuali

L'create-virtual-serviceesempio seguente utilizza un file JSON di input per creare un servizio virtuale con un provider di nodi virtuali.

aws appmesh create-virtual-service \
    --cli-input-json file://create-virtual-service-virtual-node.json

Contenuto di create-virtual-service-virtual-node.json.

{
    "meshName": "app1",
    "spec": {
        "provider": {
            "virtualNode": {
                "virtualNodeName": "vnServiceA"
            }
        }
    },
    "virtualServiceName": "serviceA.svc.cluster.local"
}

Output:

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

Per ulteriori informazioni, consulta Virtual Node nella AWS App Mesh User Guide.

Esempio 2: creare un nuovo servizio virtuale con un provider di router virtuale

L'create-virtual-serviceesempio seguente utilizza un file JSON di input per creare un servizio virtuale con un provider di router virtuale.

aws appmesh create-virtual-service \
    --cli-input-json file://create-virtual-service-virtual-router.json

Contenuto di create-virtual-service-virtual-router.json.

{
    "meshName": "app1",
    "spec": {
        "provider": {
            "virtualRouter": {
                "virtualRouterName": "vrServiceB"
            }
        }
    },
    "virtualServiceName": "serviceB.svc.cluster.local"
}

Output:

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

Per ulteriori informazioni, consulta Virtual Services< https://docs.aws.amazon.com/app-mesh/ latest/userguide/virtual_services.html> nella App Mesh User Guide AWS

Il seguente esempio di codice mostra come utilizzaredelete-mesh.

AWS CLI

Per eliminare una service mesh

L'delete-meshesempio seguente elimina la service mesh specificata.

aws appmesh delete-mesh \
    --mesh-name app1

Output:

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

Per ulteriori informazioni, consulta Service Meshes nella AWS App Mesh User Guide.

  • Per API i dettagli, vedere DeleteMeshin AWS CLI Command Reference.

Il seguente esempio di codice mostra come utilizzaredelete-route.

AWS CLI

Per eliminare un percorso

L'delete-routeesempio seguente elimina la rotta specificata.

aws appmesh delete-route \
    --mesh-name app1 \
    --virtual-router-name vrServiceB \
    --route-name toVnServiceB-weighted

Output:

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

Per ulteriori informazioni, consulta Routes nella AWS App Mesh User Guide.

  • Per API i dettagli, vedere DeleteRoutein AWS CLI Command Reference.

Il seguente esempio di codice mostra come utilizzaredelete-virtual-node.

AWS CLI

Per eliminare un nodo virtuale

L'delete-virtual-nodeesempio seguente elimina il nodo virtuale specificato.

aws appmesh delete-virtual-node \
    --mesh-name app1 \
    --virtual-node-name vnServiceBv2

Output:

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

Per ulteriori informazioni, consulta Virtual Nodes nella AWS App Mesh User Guide.

Il seguente esempio di codice mostra come utilizzaredelete-virtual-router.

AWS CLI

Per eliminare un router virtuale

L'delete-virtual-routeresempio seguente elimina il router virtuale specificato.

aws appmesh delete-virtual-router \
    --mesh-name app1 \
    --virtual-router-name vrServiceB

Output:

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

Per ulteriori informazioni, consulta Virtual Router nella AWS App Mesh User Guide.

Il seguente esempio di codice mostra come utilizzaredelete-virtual-service.

AWS CLI

Per eliminare un servizio virtuale

L'delete-virtual-serviceesempio seguente elimina il servizio virtuale specificato.

aws appmesh delete-virtual-service \
    --mesh-name app1 \
    --virtual-service-name serviceB.svc.cluster.local

Output:

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

Per ulteriori informazioni, consulta Virtual Service nella AWS App Mesh User Guide.

Il seguente esempio di codice mostra come utilizzaredescribe-mesh.

AWS CLI

Per descrivere una service mesh

L'describe-meshesempio seguente restituisce i dettagli sulla service mesh specificata.

aws appmesh describe-mesh \
    --mesh-name app1

Output:

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

Per ulteriori informazioni, consulta Service Meshes nella AWS App Mesh User Guide.

  • Per API i dettagli, vedere DescribeMeshin AWS CLI Command Reference.

Il seguente esempio di codice mostra come utilizzaredescribe-route.

AWS CLI

Per descrivere un percorso

L'describe-routeesempio seguente restituisce i dettagli sulla rotta specificata.

aws appmesh describe-route \
    --mesh-name app1 \
    --virtual-router-name vrServiceB \
    --route-name toVnServiceB-weighted

Output:

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

Per ulteriori informazioni, consulta Routes nella AWS App Mesh User Guide.

  • Per API i dettagli, vedere DescribeRoutein AWS CLI Command Reference.

Il seguente esempio di codice mostra come utilizzaredescribe-virtual-node.

AWS CLI

Per descrivere un nodo virtuale

L'describe-virtual-nodeesempio seguente restituisce i dettagli sul nodo virtuale specificato.

aws appmesh describe-virtual-node \
    --mesh-name app1 \
    --virtual-node-name vnServiceBv1

Output:

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

Per ulteriori informazioni, consulta Virtual Nodes nella AWS App Mesh User Guide.

Il seguente esempio di codice mostra come utilizzaredescribe-virtual-router.

AWS CLI

Per descrivere un router virtuale

L'describe-virtual-routeresempio seguente restituisce i dettagli sul router virtuale specificato.

aws appmesh describe-virtual-router \
    --mesh-name app1 \
    --virtual-router-name vrServiceB

Output:

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

Per ulteriori informazioni, consulta Virtual Router nella AWS App Mesh User Guide.

Il seguente esempio di codice mostra come utilizzaredescribe-virtual-service.

AWS CLI

Per descrivere un servizio virtuale

L'describe-virtual-serviceesempio seguente restituisce i dettagli sul servizio virtuale specificato.

aws appmesh describe-virtual-service \
    --mesh-name app1 \
    --virtual-service-name serviceB.svc.cluster.local

Output:

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

Per ulteriori informazioni, consulta Virtual Services nella AWS App Mesh User Guide.

Il seguente esempio di codice mostra come utilizzarelist-meshes.

AWS CLI

Per elencare le mesh di servizio

L'list-meshesesempio seguente elenca tutte le mesh di servizio nella regione corrente AWS .

aws appmesh list-meshes

Output:

{
    "meshes": [
        {
            "arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1",
            "meshName": "app1"
        }
    ]
}

Per ulteriori informazioni, consulta Service Meshes nella AWS App Mesh User Guide.

  • Per API i dettagli, vedere ListMeshesin AWS CLI Command Reference.

Il seguente esempio di codice mostra come utilizzarelist-routes.

AWS CLI

Per elencare i percorsi

L'list-routesesempio seguente elenca tutte le rotte per il router virtuale specificato.

aws appmesh list-routes \
    --mesh-name app1 \
    --virtual-router-name vrServiceB

Output:

{
    "routes": [
        {
            "arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualRouter/vrServiceB/route/toVnServiceB",
            "meshName": "app1",
            "routeName": "toVnServiceB-weighted",
            "virtualRouterName": "vrServiceB"
        }
    ]
}

Per ulteriori informazioni, consulta Routes nella AWS App Mesh User Guide.

  • Per API i dettagli, vedere ListRoutesin AWS CLI Command Reference.

Il seguente esempio di codice mostra come utilizzarelist-tags-for-resource.

AWS CLI

Per elencare i tag di una risorsa

L'list-tags-for-resourceesempio seguente elenca tutti i tag assegnati alla risorsa specificata.

aws appmesh list-tags-for-resource \
    --resource-arn arn:aws:appmesh:us-east-1:123456789012:mesh/app1

Output:

{
    "tags": [
        {
            "key": "key1",
            "value": "value1"
        },
        {
            "key": "key2",
            "value": "value2"
        },
        {
            "key": "key3",
            "value": "value3"
        }
    ]
}

Il seguente esempio di codice mostra come utilizzarelist-virtual-nodes.

AWS CLI

Per elencare i nodi virtuali

L'list-virtual-nodesesempio seguente elenca tutti i nodi virtuali nella mesh di servizio specificata.

aws appmesh list-virtual-nodes \
    --mesh-name app1

Output:

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

Per ulteriori informazioni, consulta Virtual Nodes nella AWS App Mesh User Guide.

Il seguente esempio di codice mostra come utilizzarelist-virtual-routers.

AWS CLI

Per elencare i router virtuali

L'list-virtual-routersesempio seguente elenca tutti i router virtuali nella service mesh specificata.

aws appmesh list-virtual-routers \
    --mesh-name app1

Output:

{
    "virtualRouters": [
        {
            "arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualRouter/vrServiceB",
            "meshName": "app1",
            "virtualRouterName": "vrServiceB"
        }
    ]
}

Per ulteriori informazioni, consulta Virtual Router nella AWS App Mesh User Guide.

Il seguente esempio di codice mostra come utilizzarelist-virtual-services.

AWS CLI

Per elencare i servizi virtuali

L'list-virtual-servicesesempio seguente elenca tutti i servizi virtuali nella mesh di servizi specificata.

aws appmesh list-virtual-services \
    --mesh-name app1

Output:

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

Per ulteriori informazioni, consulta Virtual Services nella AWS App Mesh User Guide.

Il seguente esempio di codice mostra come utilizzaretag-resource.

AWS CLI

Per etichettare una risorsa

L'tag-resourceesempio seguente aggiunge il tag key1 con il valore value1 alla risorsa specificata.

aws appmesh tag-resource \
    --resource-arn arn:aws:appmesh:us-east-1:123456789012:mesh/app1 \
    --tags key=key1,value=value1

Questo comando non produce alcun output.

  • Per API i dettagli, vedere TagResourcein AWS CLI Command Reference.

Il seguente esempio di codice mostra come utilizzareuntag-resource.

AWS CLI

Per rimuovere i tag da una risorsa

L'untag-resourceesempio seguente rimuove un tag con la chiave key1 dalla risorsa specificata.

aws appmesh untag-resource \
    --resource-arn arn:aws:appmesh:us-east-1:123456789012:mesh/app1 \
    --tag-keys key1

Questo comando non produce alcun output.

  • Per API i dettagli, vedere UntagResourcein AWS CLI Command Reference.

Il seguente esempio di codice mostra come utilizzareupdate-mesh.

AWS CLI

Per aggiornare una service mesh

L'update-meshesempio seguente utilizza un file JSON di input per aggiornare una service mesh per consentire l'inoltro inalterato di tutto il traffico esterno in uscita attraverso il proxy Envoy.

aws appmesh update-mesh \
    --cli-input-json file://update-mesh.json

Contenuto di update-mesh.json.

{
    "meshName": "app1",
    "spec": {
        "egressFilter": {
            "type": "ALLOW_ALL"
        }
    }
}

Output:

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

Per ulteriori informazioni, consulta Service Meshes nella AWS App Mesh User Guide.

  • Per API i dettagli, vedere UpdateMeshin AWS CLI Command Reference.

Il seguente esempio di codice mostra come utilizzareupdate-route.

AWS CLI

Per aggiornare un percorso

L'update-routeesempio seguente utilizza un file JSON di input per aggiornare i pesi di un percorso.

aws appmesh update-route \
    --cli-input-json file://update-route-weighted.json

Contenuto di 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"
}

Output:

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

Per ulteriori informazioni, consulta Routes nella AWS App Mesh User Guide.

  • Per API i dettagli, vedere UpdateRoutein AWS CLI Command Reference.

Il seguente esempio di codice mostra come utilizzareupdate-virtual-node.

AWS CLI

Per aggiornare un nodo virtuale

L'update-virtual-nodeesempio seguente utilizza un file JSON di input per aggiungere un controllo dello stato di salute a un nodo virtuale.

aws appmesh update-virtual-node \
    --cli-input-json file://update-virtual-node.json

Contenuto di 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"
}

Output:

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

Per ulteriori informazioni, consulta Virtual Nodes nella AWS App Mesh User Guide.

Il seguente esempio di codice mostra come utilizzareupdate-virtual-router.

AWS CLI

Per aggiornare un router virtuale

L'update-virtual-routeresempio seguente utilizza un file JSON di input per aggiornare una porta listener del router virtuale.

aws appmesh update-virtual-router \
    --cli-input-json file://update-virtual-router.json

Contenuto di update-virtual-router.json.

{
    "meshName": "app1",
    "spec": {
        "listeners": [
            {
                "portMapping": {
                    "port": 8080,
                    "protocol": "http"
                }
            }
        ]
    },
    "virtualRouterName": "vrServiceB"
}

Output:

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

Per ulteriori informazioni, consulta Virtual Router nella AWS App Mesh User Guide.

Il seguente esempio di codice mostra come utilizzareupdate-virtual-service.

AWS CLI

Per aggiornare un servizio virtuale

L'update-virtual-serviceesempio seguente utilizza un file JSON di input per aggiornare un servizio virtuale per utilizzare un provider di router virtuale.

aws appmesh update-virtual-service \
    --cli-input-json file://update-virtual-service.json

Contenuto di update-virtual-service.json.

{
    "meshName": "app1",
    "spec": {
        "provider": {
            "virtualRouter": {
                "virtualRouterName": "vrServiceA"
            }
        }
    },
    "virtualServiceName": "serviceA.svc.cluster.local"
}

Output:

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

Per ulteriori informazioni, consulta Virtual Services nella AWS App Mesh User Guide.