Exemplos de App Mesh usando a AWS CLI - AWS Command Line Interface
Ações

Esta documentação é somente para a versão 1 da AWS CLI. Para obter a documentação relacionada à AWS CLI versão 2, consulte o Guia do usuário da versão 2.

Exemplos de App Mesh usando a AWS CLI

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 funções 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.

Tópicos

Ações

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

Saída:

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

Saída:

{
    "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 no Guia do usuário do AWS App Mesh.

  • Para ver detalhes da API, consulte CreateMesh na Referência de comandos da AWS CLI.

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

Saída:

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

Saída:

{
    "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 um aplicativo. 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 um aplicativo.

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

Saída:

{
    "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 no Guia do usuário do AWS App Mesh.

  • Para ver detalhes da API, consulte CreateRoute na Referência de comandos da AWS CLI.

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

Saída:

{
    "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 no Guia do usuário do AWS App Mesh.

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

Saída:

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

Saída:

{
    "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 no Guia do usuário do AWS App Mesh.

  • Para ver detalhes da API, consulte CreateVirtualNode na Referência de comandos da AWS CLI.

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

Saída:

{
    "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 no Guia do usuário do AWS App Mesh.

  • Para ver detalhes da API, consulte CreateVirtualRouter na Referência de comandos da AWS CLI.

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

Saída:

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

Saída:

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

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

Saída:

{
    "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 no Guia do usuário do AWS App Mesh.

  • Para ver detalhes da API, consulte DeleteMesh na Referência de comandos da AWS CLI.

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

Saída:

{
    "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 no Guia do usuário do AWS App Mesh.

  • Para ver detalhes da API, consulte DeleteRoute na Referência de comandos da AWS CLI.

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

Saída:

{
    "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 no Guia do usuário do AWS App Mesh.

  • Para ver detalhes da API, consulte DeleteVirtualNode na Referência de comandos da AWS CLI.

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

Saída:

{
    "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 no Guia do usuário do AWS App Mesh.

  • Para ver detalhes da API, consulte DeleteVirtualRouter na Referência de comandos da AWS CLI.

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

Saída:

{
    "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 no Guia do usuário do AWS App Mesh.

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

Saída:

{
    "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 no Guia do usuário do AWS App Mesh.

  • Para ver detalhes da API, consulte DescribeMesh na Referência de comandos da AWS CLI.

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

Saída:

{
    "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 no Guia do usuário do AWS App Mesh.

  • Para ver detalhes da API, consulte DescribeRoute na Referência de comandos da AWS CLI.

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

Saída:

{
    "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 no Guia do usuário do AWS App Mesh.

  • Para ver detalhes da API, consulte DescribeVirtualNode na Referência de comandos da AWS CLI.

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

Saída:

{
    "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 no Guia do usuário do AWS App Mesh.

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

Saída:

{
    "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 no Guia do usuário do AWS App Mesh.

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

Saída:

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

Para obter mais informações, consulte Malhas de serviços no Guia do usuário do AWS App Mesh.

  • Para ver detalhes da API, consulte ListMeshes na Referência de comandos da AWS CLI.

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

Saída:

{
    "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 no Guia do usuário do AWS App Mesh.

  • Para ver detalhes da API, consulte ListRoutes na Referência de comandos da AWS CLI.

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

Saída:

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

  • Para ver detalhes sobre a API, consulte ListTagsForResource na Referência de comandos da AWS CLI.

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

Saída:

{
    "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 no Guia do usuário do AWS App Mesh.

  • Para ver detalhes da API, consulte ListVirtualNodes na Referência de comandos da AWS CLI.

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

Saída:

{
    "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 no Guia do usuário do AWS App Mesh.

  • Para ver detalhes da API, consulte ListVirtualRouters na Referência de comandos da AWS CLI.

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

Saída:

{
    "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 no Guia do usuário do AWS App Mesh.

  • Para ver detalhes da API, consulte ListVirtualServices na Referência de comandos da AWS CLI.

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.

  • Para obter detalhes da API, consulte TagResource na Referência de comandos da AWS CLI.

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 na Referência de comandos da AWS CLI.

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

Saída:

{
    "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 no Guia do usuário do AWS App Mesh.

  • Para ver detalhes da API, consulte UpdateMesh na Referência de comandos da AWS CLI.

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

Saída:

{
    "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 no Guia do usuário do AWS App Mesh.

  • Para ver detalhes da API, consulte UpdateRoute na Referência de comandos da AWS CLI.

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

Saída:

{
    "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 no Guia do usuário do AWS App Mesh.

  • Para ver detalhes da API, consulte UpdateVirtualNode na Referência de comandos da AWS CLI.

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

Saída:

{
    "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 no Guia do usuário do AWS App Mesh.

  • Para ver detalhes da API, consulte UpdateVirtualRouter na Referência de comandos da AWS CLI.

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

Saída:

{
    "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 no Guia do usuário do AWS App Mesh.