# Exemplos de App Mesh usando a AWS CLI
<a name="cli_app-mesh_code_examples"></a>

Os exemplos de código a seguir mostram como realizar ações e implementar cenários comuns usando o AWS Command Line Interface com o App Mesh.

*Ações* são trechos de código de programas maiores e devem ser executadas em contexto. Embora as ações mostrem como chamar perfis de serviço individuais, você pode ver as ações no contexto em seus cenários relacionados.

Cada exemplo inclui um link para o código-fonte completo, em que você pode encontrar instruções sobre como configurar e executar o código.

**Topics**
+ [Ações](#actions)

## Ações
<a name="actions"></a>

### `create-mesh`
<a name="app-mesh_CreateMesh_cli_topic"></a>

O código de exemplo a seguir mostra como usar `create-mesh`.

**AWS CLI**  
**Exemplo 1: criar uma nova malha de serviços**  
O exemplo `create-mesh` a seguir cria uma malha de serviços.  

```
aws appmesh create-mesh \
    --mesh-name app1
```
Resultado:  

```
{
    "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"
        }
    }
}
```
**Exemplo 2: criar uma nova malha de serviços com várias tags**  
O exemplo `create-mesh` a seguir cria uma malha de serviços com várias tags.  

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

```
{
    "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"
        }
    }
}
```
Para obter mais informações, consulte [Malhas de serviços](https://docs.aws.amazon.com/app-mesh/latest/userguide/meshes.html) no *Guia do usuário do AWS App Mesh*.  
+  Para ver detalhes da API, consulte [CreateMesh](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/create-mesh.html) na *Referência de comandos da AWS CLI*. 

### `create-route`
<a name="app-mesh_CreateRoute_cli_topic"></a>

O código de exemplo a seguir mostra como usar `create-route`.

**AWS CLI**  
**Para criar uma nova rota gRPC**  
O exemplo `create-route` a seguir usa um arquivo de entrada JSON para criar uma rota gRPC. O tráfego de GRPC que tem metadados que começam com 123 é roteado para um nó virtual chamado serviceBgrpc. Se houver falhas específicas de gRPC, HTTP ou TCP ao tentar se comunicar com o destino da rota, a rota será repetida três vezes. Há um atraso de 15 segundos entre cada nova tentativa.  

```
aws appmesh create-route \
    --cli-input-json file://create-route-grpc.json
```
Conteúdo de `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"
}
```
Resultado:  

```
{
    "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"
    }
}
```
**Para criar uma nova rota HTTP ou HTTP/2**  
O exemplo `create-route` a seguir usa um arquivo de entrada JSON para criar uma rota HTTP/2. Para criar uma rota HTTP, substitua http2Route por httpRoute na especificação. Todo o tráfego HTTP/2 endereçado a qualquer prefixo de URL que tenha um valor de cabeçalho que comece com 123 é roteado para um nó virtual chamado serviceBhttp2. Se houver falhas específicas de HTTP ou TCP ao tentar se comunicar com o destino da rota, a rota será repetida três vezes. Há um atraso de 15 segundos entre cada nova tentativa.  

```
aws appmesh create-route \
    --cli-input-json file://create-route-http2.json
```
Conteúdo de `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"
}
```
Resultado:  

```
{
    "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"
    }
}
```
**Para criar uma nova rota TCP**  
O exemplo `create-route` a seguir usa um arquivo de entrada JSON para criar uma rota TCP, em que 75% do tráfego é roteado para um nó virtual chamado serviceBtcp e 25% do tráfego é roteado para um nó virtual chamado serviceBv2tcp. Especificar pesos diferentes para destinos diferentes é uma forma eficaz para implantação de uma nova versão de uma aplicação. Você pode ajustar os pesos para que, por fim, 100% de todo o tráfego seja roteado para um destino que tenha a nova versão de uma aplicação.  

```
aws appmesh create-route \
    --cli-input-json file://create-route-tcp.json
```
Conteúdo do create-route-tcp.json:  

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

```
{
    "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"
    }
}
```
Para obter mais informações, consulte [Rotas](https://docs.aws.amazon.com/app-mesh/latest/userguide/routes.html) no *Guia do usuário do AWS App Mesh*.  
+  Para ver detalhes da API, consulte [CreateRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/create-route.html) na *Referência de comandos da AWS CLI*. 

### `create-virtual-gateway`
<a name="app-mesh_CreateVirtualGateway_cli_topic"></a>

O código de exemplo a seguir mostra como usar `create-virtual-gateway`.

**AWS CLI**  
**Para criar um gateway privado virtual**  
O exemplo `create-virtual-gateway` a seguir usa um arquivo de entrada JSON para criar um gateway virtual com um receptor para HTTP usando a porta 9080.  

```
aws appmesh create-virtual-gateway \
    --mesh-name meshName \
    --virtual-gateway-name virtualGatewayName \
    --cli-input-json file://create-virtual-gateway.json
```
Conteúdo de `create-virtual-gateway.json`:  

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

```
{
    "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"
    }
}
```
Para obter mais informações, consulte [Gateways virtuais](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_gateways.html) no *Guia do usuário do AWS App Mesh*.  
+  Para ver detalhes da API, consulte [CreateVirtualGateway](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/create-virtual-gateway.html) na *Referência de comandos da AWS CLI*. 

### `create-virtual-node`
<a name="app-mesh_CreateVirtualNode_cli_topic"></a>

O código de exemplo a seguir mostra como usar `create-virtual-node`.

**AWS CLI**  
**Exemplo 1: criar um novo nó virtual que usa DNS para descoberta**  
O exemplo `create-virtual-node` a seguir usa um arquivo de entrada JSON para criar um nó virtual que usa DNS para descoberta de serviços.  

```
aws appmesh create-virtual-node \
    --cli-input-json file://create-virtual-node-dns.json
```
Conteúdo de `create-virtual-node-dns.json`:  

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

```
{
    "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"
    }
}
```
**Exemplo 2: criar um novo nó virtual que usa o AWS Cloud Map para descoberta**  
O exemplo `create-virtual-node` a seguir usa um arquivo de entrada JSON para criar um nó virtual que usa o AWS Cloud Map para descoberta de serviços.  

```
aws appmesh create-virtual-node \
    --cli-input-json file://create-virtual-node-cloud-map.json
```
Conteúdo de `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"
}
```
Resultado:  

```
{
    "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"
    }
}
```
Para obter mais informações, consulte [Nós virtuais](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_nodes.html) no *Guia do usuário do AWS App Mesh*.  
+  Para ver detalhes da API, consulte [CreateVirtualNode](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/create-virtual-node.html) na *Referência de comandos da AWS CLI*. 

### `create-virtual-router`
<a name="app-mesh_CreateVirtualRouter_cli_topic"></a>

O código de exemplo a seguir mostra como usar `create-virtual-router`.

**AWS CLI**  
**Para criar um roteador virtual**  
O exemplo `create-virtual-router` a seguir usa um arquivo de entrada JSON para criar um roteador virtual com um receptor para HTTP usando a porta 80.  

```
aws appmesh create-virtual-router \
    --cli-input-json file://create-virtual-router.json
```
Conteúdo de `create-virtual-router.json`:  

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

```
{
    "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"
    }
}
```
Para obter mais informações, consulte [Roteadores virtuais](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_routers.html) no *Guia do usuário do AWS App Mesh*.  
+  Para ver detalhes da API, consulte [CreateVirtualRouter](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/create-virtual-router.html) na *Referência de comandos da AWS CLI*. 

### `create-virtual-service`
<a name="app-mesh_CreateVirtualService_cli_topic"></a>

O código de exemplo a seguir mostra como usar `create-virtual-service`.

**AWS CLI**  
**Exemplo 1: criar um novo serviço virtual com um provedor de nós virtuais**  
O exemplo `create-virtual-service` a seguir usa um arquivo de entrada JSON para criar um serviço virtual com um provedor de nó virtual.  

```
aws appmesh create-virtual-service \
    --cli-input-json file://create-virtual-service-virtual-node.json
```
Conteúdo de `create-virtual-service-virtual-node.json`:  

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

```
{
    "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"
    }
}
```
Para obter mais informações, consulte [Nó virtual](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_nodes.html) no *Guia do usuário do AWS App Mesh*.  
**Exemplo 2: criar um novo serviço virtual com um provedor de roteador virtual**  
O exemplo `create-virtual-service` a seguir usa um arquivo de entrada JSON para criar um serviço virtual com um provedor de roteador virtual.  

```
aws appmesh create-virtual-service \
    --cli-input-json file://create-virtual-service-virtual-router.json
```
Conteúdo de `create-virtual-service-virtual-router.json`:  

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

```
{
    "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"
    }
}
```
Para obter mais informações, consulte Serviços virtuais <https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual\$1services.html> no *Guia do usuário do AWS App Mesh*  
+  Para ver detalhes da API, consulte [CreateVirtualService](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/create-virtual-service.html) na *Referência de comandos da AWS CLI*. 

### `delete-mesh`
<a name="app-mesh_DeleteMesh_cli_topic"></a>

O código de exemplo a seguir mostra como usar `delete-mesh`.

**AWS CLI**  
**Para excluir uma malha de serviços**  
O exemplo `delete-mesh` a seguir exclui o serviço especificado de uma malha de serviços.  

```
aws appmesh delete-mesh \
    --mesh-name app1
```
Resultado:  

```
{
    "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"
        }
    }
}
```
Para obter mais informações, consulte [Malhas de serviços](https://docs.aws.amazon.com/app-mesh/latest/userguide/meshes.html) no *Guia do usuário do AWS App Mesh*.  
+  Para ver detalhes da API, consulte [DeleteMesh](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/delete-mesh.html) na *Referência de comandos da AWS CLI*. 

### `delete-route`
<a name="app-mesh_DeleteRoute_cli_topic"></a>

O código de exemplo a seguir mostra como usar `delete-route`.

**AWS CLI**  
**Para excluir uma rota**  
O exemplo `delete-route` a seguir exclui a rota especificada.  

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

```
{
    "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"
    }
}
```
Para obter mais informações, consulte [Rotas](https://docs.aws.amazon.com/app-mesh/latest/userguide/routes.html) no *Guia do usuário do AWS App Mesh*.  
+  Para ver detalhes da API, consulte [DeleteRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/delete-route.html) na *Referência de comandos da AWS CLI*. 

### `delete-virtual-node`
<a name="app-mesh_DeleteVirtualNode_cli_topic"></a>

O código de exemplo a seguir mostra como usar `delete-virtual-node`.

**AWS CLI**  
**Para excluir um nó virtual**  
O exemplo `delete-virtual-node` a seguir exclui o nó virtual especificado.  

```
aws appmesh delete-virtual-node \
    --mesh-name app1 \
    --virtual-node-name vnServiceBv2
```
Resultado:  

```
{
    "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"
    }
}
```
Para obter mais informações, consulte [Nós virtuais](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_nodes.html) no *Guia do usuário do AWS App Mesh*.  
+  Para ver detalhes da API, consulte [DeleteVirtualNode](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/delete-virtual-node.html) na *Referência de comandos da AWS CLI*. 

### `delete-virtual-router`
<a name="app-mesh_DeleteVirtualRouter_cli_topic"></a>

O código de exemplo a seguir mostra como usar `delete-virtual-router`.

**AWS CLI**  
**Para excluir um roteador virtual**  
O exemplo `delete-virtual-router` a seguir exclui o roteador virtual especificado.  

```
aws appmesh delete-virtual-router \
    --mesh-name app1 \
    --virtual-router-name vrServiceB
```
Resultado:  

```
{
    "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"
    }
}
```
Para obter mais informações, consulte [Roteadores virtuais](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_routers.html) no *Guia do usuário do AWS App Mesh*.  
+  Para ver detalhes da API, consulte [DeleteVirtualRouter](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/delete-virtual-router.html) na *Referência de comandos da AWS CLI*. 

### `delete-virtual-service`
<a name="app-mesh_DeleteVirtualService_cli_topic"></a>

O código de exemplo a seguir mostra como usar `delete-virtual-service`.

**AWS CLI**  
**Com excluir um serviço virtual**  
O exemplo `delete-virtual-service` a seguir exclui o serviço virtual especificado.  

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

```
{
    "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"
    }
}
```
Para obter mais informações, consulte [Serviço virtual](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_services.html) no *Guia do usuário do AWS App Mesh*.  
+  Para ver detalhes da API, consulte [DeleteVirtualService](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/delete-virtual-service.html) na *Referência de comandos da AWS CLI*. 

### `describe-mesh`
<a name="app-mesh_DescribeMesh_cli_topic"></a>

O código de exemplo a seguir mostra como usar `describe-mesh`.

**AWS CLI**  
**Para descrever uma malha de serviços**  
O exemplo `describe-mesh` a seguir retorna detalhes da malha de serviços especificada.  

```
aws appmesh describe-mesh \
    --mesh-name app1
```
Resultado:  

```
{
    "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"
        }
    }
}
```
Para obter mais informações, consulte [Malhas de serviços](https://docs.aws.amazon.com/app-mesh/latest/userguide/meshes.html) no *Guia do usuário do AWS App Mesh*.  
+  Para ver detalhes da API, consulte [DescribeMesh](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/describe-mesh.html) na *Referência de comandos da AWS CLI*. 

### `describe-route`
<a name="app-mesh_DescribeRoute_cli_topic"></a>

O código de exemplo a seguir mostra como usar `describe-route`.

**AWS CLI**  
**Para descrever uma rota**  
O exemplo `describe-route` a seguir retorna detalhes da rota especificada.  

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

```
{
    "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"
    }
}
```
Para obter mais informações, consulte [Rotas](https://docs.aws.amazon.com/app-mesh/latest/userguide/routes.html) no *Guia do usuário do AWS App Mesh*.  
+  Para ver detalhes da API, consulte [DescribeRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/describe-route.html) na *Referência de comandos da AWS CLI*. 

### `describe-virtual-node`
<a name="app-mesh_DescribeVirtualNode_cli_topic"></a>

O código de exemplo a seguir mostra como usar `describe-virtual-node`.

**AWS CLI**  
**Para descrever um nó virtual**  
O exemplo `describe-virtual-node` a seguir retorna detalhes do nó virtual especificado.  

```
aws appmesh describe-virtual-node \
    --mesh-name app1 \
    --virtual-node-name vnServiceBv1
```
Resultado:  

```
{
    "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"
    }
}
```
Para obter mais informações, consulte [Nós virtuais](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_nodes.html) no *Guia do usuário do AWS App Mesh*.  
+  Para ver detalhes da API, consulte [DescribeVirtualNode](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/describe-virtual-node.html) na *Referência de comandos da AWS CLI*. 

### `describe-virtual-router`
<a name="app-mesh_DescribeVirtualRouter_cli_topic"></a>

O código de exemplo a seguir mostra como usar `describe-virtual-router`.

**AWS CLI**  
**Para descrever um roteador virtual**  
O exemplo `describe-virtual-router` a seguir retorna detalhes do roteador virtual especificado.  

```
aws appmesh describe-virtual-router \
    --mesh-name app1 \
    --virtual-router-name vrServiceB
```
Resultado:  

```
{
    "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"
    }
}
```
Para obter mais informações, consulte [Roteadores virtuais](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_routers.html) no *Guia do usuário do AWS App Mesh*.  
+  Para ver detalhes da API, consulte [DescribeVirtualRouter](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/describe-virtual-router.html) na *Referência de comandos da AWS CLI*. 

### `describe-virtual-service`
<a name="app-mesh_DescribeVirtualService_cli_topic"></a>

O código de exemplo a seguir mostra como usar `describe-virtual-service`.

**AWS CLI**  
**Para descrever um serviço virtual**  
O exemplo `describe-virtual-service` a seguir retorna detalhes do serviço virtual especificado.  

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

```
{
    "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"
    }
}
```
Para obter mais informações, consulte [Serviços virtuais](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_services.html) no *Guia do usuário do AWS App Mesh*.  
+  Para ver detalhes da API, consulte [DescribeVirtualService](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/describe-virtual-service.html) na *Referência de comandos da AWS CLI*. 

### `list-meshes`
<a name="app-mesh_ListMeshes_cli_topic"></a>

O código de exemplo a seguir mostra como usar `list-meshes`.

**AWS CLI**  
**Para listar malhas de serviços**  
O exemplo `list-meshes` a seguir lista todas as malhas de serviços na região da AWS atual.  

```
aws appmesh list-meshes
```
Resultado:  

```
{
    "meshes": [
        {
            "arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1",
            "meshName": "app1"
        }
    ]
}
```
Para obter mais informações, consulte [Malhas de serviços](https://docs.aws.amazon.com/app-mesh/latest/userguide/meshes.html) no *Guia do usuário do AWS App Mesh*.  
+  Para ver detalhes da API, consulte [ListMeshes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/list-meshes.html) na *Referência de comandos da AWS CLI*. 

### `list-routes`
<a name="app-mesh_ListRoutes_cli_topic"></a>

O código de exemplo a seguir mostra como usar `list-routes`.

**AWS CLI**  
**Para listar rotas**  
O exemplo `list-routes` a seguir lista todas as rotas para o roteador virtual especificado.  

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

```
{
    "routes": [
        {
            "arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualRouter/vrServiceB/route/toVnServiceB",
            "meshName": "app1",
            "routeName": "toVnServiceB-weighted",
            "virtualRouterName": "vrServiceB"
        }
    ]
}
```
Para obter mais informações, consulte [Rotas](https://docs.aws.amazon.com/app-mesh/latest/userguide/routes.html) no *Guia do usuário do AWS App Mesh*.  
+  Para ver detalhes da API, consulte [ListRoutes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/list-routes.html) na *Referência de comandos da AWS CLI*. 

### `list-tags-for-resource`
<a name="app-mesh_ListTagsForResource_cli_topic"></a>

O código de exemplo a seguir mostra como usar `list-tags-for-resource`.

**AWS CLI**  
**Para listar as tags para um recurso**  
O exemplo `list-tags-for-resource` a seguir lista todas as tags atribuídas ao recurso especificado.  

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

```
{
    "tags": [
        {
            "key": "key1",
            "value": "value1"
        },
        {
            "key": "key2",
            "value": "value2"
        },
        {
            "key": "key3",
            "value": "value3"
        }
    ]
}
```
+  Para obter detalhes sobre a API, consulte [ListTagsForResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/list-tags-for-resource.html) na *AWS CLI Command Reference*. 

### `list-virtual-nodes`
<a name="app-mesh_ListVirtualNodes_cli_topic"></a>

O código de exemplo a seguir mostra como usar `list-virtual-nodes`.

**AWS CLI**  
**Para listar nós virtuais**  
O exemplo `list-virtual-nodes` a seguir lista todos os nós virtuais na malha de serviços especificada.  

```
aws appmesh list-virtual-nodes \
    --mesh-name app1
```
Resultado:  

```
{
    "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"
        }
    ]
}
```
Para obter mais informações, consulte [Nós virtuais](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_nodes.html) no *Guia do usuário do AWS App Mesh*.  
+  Para ver detalhes da API, consulte [ListVirtualNodes](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/list-virtual-nodes.html) na *Referência de comandos da AWS CLI*. 

### `list-virtual-routers`
<a name="app-mesh_ListVirtualRouters_cli_topic"></a>

O código de exemplo a seguir mostra como usar `list-virtual-routers`.

**AWS CLI**  
**Para listar roteadores virtuais**  
O exemplo `list-virtual-routers` a seguir lista todos os roteadores virtuais na malha de serviços especificada.  

```
aws appmesh list-virtual-routers \
    --mesh-name app1
```
Resultado:  

```
{
    "virtualRouters": [
        {
            "arn": "arn:aws:appmesh:us-east-1:123456789012:mesh/app1/virtualRouter/vrServiceB",
            "meshName": "app1",
            "virtualRouterName": "vrServiceB"
        }
    ]
}
```
Para obter mais informações, consulte [Roteadores virtuais](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_routers.html) no *Guia do usuário do AWS App Mesh*.  
+  Para ver detalhes da API, consulte [ListVirtualRouters](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/list-virtual-routers.html) na *Referência de comandos da AWS CLI*. 

### `list-virtual-services`
<a name="app-mesh_ListVirtualServices_cli_topic"></a>

O código de exemplo a seguir mostra como usar `list-virtual-services`.

**AWS CLI**  
**Para listar serviços virtuais**  
O exemplo `list-virtual-services` a seguir lista todos os serviços virtuais na malha de serviços especificada.  

```
aws appmesh list-virtual-services \
    --mesh-name app1
```
Resultado:  

```
{
    "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"
        }
    ]
}
```
Para obter mais informações, consulte [Serviços virtuais](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_services.html) no *Guia do usuário do AWS App Mesh*.  
+  Para ver detalhes da API, consulte [ListVirtualServices](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/list-virtual-services.html) na *Referência de comandos da AWS CLI*. 

### `tag-resource`
<a name="app-mesh_TagResource_cli_topic"></a>

O código de exemplo a seguir mostra como usar `tag-resource`.

**AWS CLI**  
**Como marcar um recurso**  
O exemplo `tag-resource` a seguir adiciona a tag `key1` com o valor `value1` ao recursos especificado.  

```
aws appmesh tag-resource \
    --resource-arn arn:aws:appmesh:us-east-1:123456789012:mesh/app1 \
    --tags key=key1,value=value1
```
Este comando não produz saída.  
+  Consulte detalhes da API em [TagResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/tag-resource.html) na *Referência de comandos da AWS CLI*. 

### `untag-resource`
<a name="app-mesh_UntagResource_cli_topic"></a>

O código de exemplo a seguir mostra como usar `untag-resource`.

**AWS CLI**  
**Como desmarcar um recurso**  
O exemplo `untag-resource` a seguir remove a tag com a chave `key1` do recurso especificado.  

```
aws appmesh untag-resource \
    --resource-arn arn:aws:appmesh:us-east-1:123456789012:mesh/app1 \
    --tag-keys key1
```
Este comando não produz saída.  
+  Para obter detalhes sobre a API, consulte [UntagResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/untag-resource.html) na *Referência de comandos da AWS CLI*. 

### `update-mesh`
<a name="app-mesh_UpdateMesh_cli_topic"></a>

O código de exemplo a seguir mostra como usar `update-mesh`.

**AWS CLI**  
**Para atualizar uma malha de serviços**  
O exemplo `update-mesh` a seguir usa um arquivo de entrada JSON para atualizar uma malha de serviços para permitir que todo o tráfego de saída externo seja encaminhado pelo proxy Envoy intocado.  

```
aws appmesh update-mesh \
    --cli-input-json file://update-mesh.json
```
Conteúdo de `update-mesh.json`:  

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

```
{
    "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"
        }
    }
}
```
Para obter mais informações, consulte [Malhas de serviços](https://docs.aws.amazon.com/app-mesh/latest/userguide/meshes.html) no *Guia do usuário do AWS App Mesh*.  
+  Para ver detalhes da API, consulte [UpdateMesh](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/update-mesh.html) na *Referência de comandos da AWS CLI*. 

### `update-route`
<a name="app-mesh_UpdateRoute_cli_topic"></a>

O código de exemplo a seguir mostra como usar `update-route`.

**AWS CLI**  
**Para atualizar uma rota**  
O exemplo `update-route` a seguir usa um arquivo de entrada JSON para atualizar os pesos de uma rota.  

```
aws appmesh update-route \
    --cli-input-json file://update-route-weighted.json
```
Conteúdo de `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"
}
```
Resultado:  

```
{
    "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"
    }
}
```
Para obter mais informações, consulte [Rotas](https://docs.aws.amazon.com/app-mesh/latest/userguide/routes.html) no *Guia do usuário do AWS App Mesh*.  
+  Para ver detalhes da API, consulte [UpdateRoute](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/update-route.html) na *Referência de comandos da AWS CLI*. 

### `update-virtual-node`
<a name="app-mesh_UpdateVirtualNode_cli_topic"></a>

O código de exemplo a seguir mostra como usar `update-virtual-node`.

**AWS CLI**  
**Para atualizar um nó virtual**  
O exemplo `update-virtual-node` a seguir usa um arquivo de entrada JSON para adicionar uma verificação de integridade a um nó virtual.  

```
aws appmesh update-virtual-node \
    --cli-input-json file://update-virtual-node.json
```
Conteúdo de `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"
}
```
Resultado:  

```
{
    "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"
    }
}
```
Para obter mais informações, consulte [Nós virtuais](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_nodes.html) no *Guia do usuário do AWS App Mesh*.  
+  Para ver detalhes da API, consulte [UpdateVirtualNode](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/update-virtual-node.html) na *Referência de comandos da AWS CLI*. 

### `update-virtual-router`
<a name="app-mesh_UpdateVirtualRouter_cli_topic"></a>

O código de exemplo a seguir mostra como usar `update-virtual-router`.

**AWS CLI**  
**Para atualizar um roteador virtual**  
O exemplo `update-virtual-router` a seguir usa um arquivo de entrada JSON para atualizar uma porta do receptor do roteador virtual.  

```
aws appmesh update-virtual-router \
    --cli-input-json file://update-virtual-router.json
```
Conteúdo de `update-virtual-router.json`:  

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

```
{
    "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"
    }
}
```
Para obter mais informações, consulte [Roteadores virtuais](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_routers.html) no *Guia do usuário do AWS App Mesh*.  
+  Para ver detalhes da API, consulte [UpdateVirtualRouter](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/update-virtual-router.html) na *Referência de comandos da AWS CLI*. 

### `update-virtual-service`
<a name="app-mesh_UpdateVirtualService_cli_topic"></a>

O código de exemplo a seguir mostra como usar `update-virtual-service`.

**AWS CLI**  
**Para atualizar um serviço virtual**  
O exemplo `update-virtual-service` a seguir usa um arquivo de entrada JSON para atualizar um serviço virtual para usar um provedor de roteador virtual.  

```
aws appmesh update-virtual-service \
    --cli-input-json file://update-virtual-service.json
```
Conteúdo de `update-virtual-service.json`:  

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

```
{
    "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"
    }
}
```
Para obter mais informações, consulte [Serviços virtuais](https://docs.aws.amazon.com/app-mesh/latest/userguide/virtual_services.html) no *Guia do usuário do AWS App Mesh*.  
+  Para ver detalhes da API, consulte [UpdateVirtualService](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appmesh/update-virtual-service.html) na *Referência de comandos da AWS CLI*.