Exemplos de App Mesh usando 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, onde você pode encontrar instruções sobre como configurar e executar o código no contexto.

Tópicos

Ações

Ações

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

AWS CLI

Exemplo 1: Para criar uma nova malha de serviços

O create-mesh exemplo 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: Para criar uma nova malha de serviços com várias tags

O create-mesh exemplo 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 Service Meshes no Guia do usuário do AWS App Mesh.

Para API obter detalhes, consulte CreateMeshna Referência de AWS CLI Comandos.

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

AWS CLI

Para criar uma nova RPC rota g

O create-route exemplo a seguir usa um arquivo JSON de entrada para criar uma RPC rota g. GRPCo tráfego que tem metadados que começam com 123 é roteado para um nó virtual chamado. serviceBgrpc Se houver TCP falhas específicas de g RPCHTTP,, ou 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 rota nova HTTP ou HTTP /2

O create-route exemplo a seguir usa um arquivo JSON de entrada para criar uma rota HTTP /2. Para criar uma HTTP rota, substitua http2Route por httpRoute under spec. Todo o tráfego HTTP /2 endereçado a qualquer URL prefixo que tenha um valor de cabeçalho que comece com 123 é roteado para um nó virtual chamado 2. serviceBhttp Se houver falhas específicas HTTP ou TCP falhas 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 TCP rota

O create-route exemplo a seguir usa um arquivo JSON de entrada para criar uma TCP rota. 75 por cento do tráfego é roteado para um nó virtual chamado serviceBtcp e 25 por cento do tráfego é roteado para um nó virtual chamado serviceBv 2tcp. Especificar pesos diferentes para alvos diferentes é uma forma eficaz de implantar uma nova versão de um aplicativo. Você pode ajustar os pesos para que, eventualmente, 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 create-route-tcp do.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 Routes no Guia do usuário do AWS App Mesh.

Para API obter detalhes, consulte CreateRoutena Referência de AWS CLI Comandos.

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

AWS CLI

Para criar um novo gateway virtual

O create-virtual-gateway exemplo a seguir usa um arquivo JSON de entrada para criar um gateway virtual com um ouvinte para HTTP usar 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 Virtual Gateways no Guia do Usuário do AWS App Mesh.

Para API obter detalhes, consulte CreateVirtualGatewayna Referência de AWS CLI Comandos.

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

AWS CLI

Exemplo 1: Para criar um novo nó virtual usado DNS para descoberta

O create-virtual-node exemplo a seguir usa um arquivo JSON de entrada para criar um nó virtual usado 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: Para criar um novo nó virtual que usa o AWS Cloud Map para descoberta

O create-virtual-node exemplo a seguir usa um arquivo JSON de entrada 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 Virtual Nodes no Guia do Usuário do AWS App Mesh.

Para API obter detalhes, consulte CreateVirtualNodena Referência de AWS CLI Comandos.

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

AWS CLI

Para criar um novo roteador virtual

O create-virtual-router exemplo a seguir usa um arquivo JSON de entrada para criar um roteador virtual com um ouvinte para HTTP usar 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 API obter detalhes, consulte CreateVirtualRouterna Referência de AWS CLI Comandos.

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

AWS CLI

Exemplo 1: Para criar um novo serviço virtual com um provedor de nós virtuais

O create-virtual-service exemplo a seguir usa um arquivo JSON de entrada 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 Virtual Node no Guia do Usuário do AWS App Mesh.

Exemplo 2: Para criar um novo serviço virtual com um provedor de roteador virtual

O create-virtual-service exemplo a seguir usa um arquivo JSON de entrada 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 Virtual Services< https://docs.aws.amazon.com/app-mesh/ latest/userguide/virtual_services.html> no Guia do usuário do App Mesh AWS

Para API obter detalhes, consulte CreateVirtualServicena Referência de AWS CLI Comandos.

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

AWS CLI

Para excluir uma malha de serviços

O delete-mesh exemplo a seguir exclui a malha de serviços especificada.


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

Para API obter detalhes, consulte DeleteMeshna Referência de AWS CLI Comandos.

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

AWS CLI

Para excluir uma rota

O delete-route exemplo 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 Routes no Guia do usuário do AWS App Mesh.

Para API obter detalhes, consulte DeleteRoutena Referência de AWS CLI Comandos.

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

AWS CLI

Para excluir um nó virtual

O delete-virtual-node exemplo 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 Virtual Nodes no Guia do Usuário do AWS App Mesh.

Para API obter detalhes, consulte DeleteVirtualNodena Referência de AWS CLI Comandos.

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

AWS CLI

Para excluir um roteador virtual

O delete-virtual-router exemplo 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 API obter detalhes, consulte DeleteVirtualRouterna Referência de AWS CLI Comandos.

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

AWS CLI

Para excluir um serviço virtual

O delete-virtual-service exemplo 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.

Para API obter detalhes, consulte DeleteVirtualServicena Referência de AWS CLI Comandos.

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

AWS CLI

Para descrever uma malha de serviços

O describe-mesh exemplo a seguir retorna detalhes sobre a 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 Service Meshes no Guia do usuário do AWS App Mesh.

Para API obter detalhes, consulte DescribeMeshna Referência de AWS CLI Comandos.

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

AWS CLI

Para descrever uma rota

O describe-route exemplo a seguir retorna detalhes sobre a 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 Routes no Guia do usuário do AWS App Mesh.

Para API obter detalhes, consulte DescribeRoutena Referência de AWS CLI Comandos.

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

AWS CLI

Para descrever um nó virtual

O describe-virtual-node exemplo a seguir retorna detalhes sobre o 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 Virtual Nodes no Guia do Usuário do AWS App Mesh.

Para API obter detalhes, consulte DescribeVirtualNodena Referência de AWS CLI Comandos.

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

AWS CLI

Para descrever um roteador virtual

O describe-virtual-router exemplo a seguir retorna detalhes sobre o 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.

Para API obter detalhes, consulte DescribeVirtualRouterna Referência de AWS CLI Comandos.

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

AWS CLI

Para descrever um serviço virtual

O describe-virtual-service exemplo a seguir retorna detalhes sobre o 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.

Para API obter detalhes, consulte DescribeVirtualServicena Referência de AWS CLI Comandos.

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

AWS CLI

Para listar malhas de serviço

O list-meshes exemplo a seguir lista todas as malhas de serviço na AWS região 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 Service Meshes no Guia do usuário do AWS App Mesh.

Para API obter detalhes, consulte ListMeshesna Referência de AWS CLI Comandos.

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

AWS CLI

Para listar rotas

O list-routes exemplo 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 Routes no Guia do usuário do AWS App Mesh.

Para API obter detalhes, consulte ListRoutesna Referência de AWS CLI Comandos.

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

AWS CLI

Para listar as tags de um recurso

O list-tags-for-resource exemplo 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 API obter detalhes, consulte ListTagsForResourcena Referência de AWS CLI Comandos.

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

AWS CLI

Para listar nós virtuais

O list-virtual-nodes exemplo 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 Virtual Nodes no Guia do Usuário do AWS App Mesh.

Para API obter detalhes, consulte ListVirtualNodesna Referência de AWS CLI Comandos.

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

AWS CLI

Para listar roteadores virtuais

O list-virtual-routers exemplo a seguir lista todos os roteadores virtuais na malha de serviço 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 API obter detalhes, consulte ListVirtualRoutersna Referência de AWS CLI Comandos.

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

AWS CLI

Para listar serviços virtuais

O list-virtual-services exemplo 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 API obter detalhes, consulte ListVirtualServicesna Referência de AWS CLI Comandos.

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

AWS CLI

Para marcar um recurso

O tag-resource exemplo a seguir adiciona a tag key1 com o valor value1 ao recurso 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 API obter detalhes, consulte TagResourcena Referência de AWS CLI Comandos.

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

AWS CLI

Para desmarcar um recurso

O untag-resource exemplo a seguir remove uma 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 API obter detalhes, consulte UntagResourcena Referência de AWS CLI Comandos.

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

AWS CLI

Para atualizar uma malha de serviços

O update-mesh exemplo a seguir usa um arquivo JSON de entrada 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 Service Meshes no Guia do usuário do AWS App Mesh.

Para API obter detalhes, consulte UpdateMeshna Referência de AWS CLI Comandos.

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

AWS CLI

Para atualizar uma rota

O update-route exemplo a seguir usa um arquivo JSON de entrada 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 Routes no Guia do usuário do AWS App Mesh.

Para API obter detalhes, consulte UpdateRoutena Referência de AWS CLI Comandos.

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

AWS CLI

Para atualizar um nó virtual

O update-virtual-node exemplo a seguir usa um arquivo JSON de entrada para adicionar uma verificação de saúde 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 Virtual Nodes no Guia do Usuário do AWS App Mesh.

Para API obter detalhes, consulte UpdateVirtualNodena Referência de AWS CLI Comandos.

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

AWS CLI

Para atualizar um roteador virtual

O update-virtual-router exemplo a seguir usa um arquivo JSON de entrada para atualizar uma porta de ouvinte de 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 API obter detalhes, consulte UpdateVirtualRouterna Referência de AWS CLI Comandos.

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

AWS CLI

Para atualizar um serviço virtual

O update-virtual-service exemplo a seguir usa um arquivo JSON de entrada 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.

Para API obter detalhes, consulte UpdateVirtualServicena Referência de AWS CLI Comandos.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

APIGerenciamento de gateway API

App Runner