As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Começando a usar AWS App Mesh o Amazon EC2
**Importante**
Aviso de fim do suporte: em 30 de setembro de 2026, AWS o suporte para o. AWS App Mesh Depois de 30 de setembro de 2026, você não poderá mais acessar o AWS App Mesh console ou os AWS App Mesh recursos. Para obter mais informações, visite esta postagem no blog [Migrando do AWS App Mesh Amazon ECS Service Connect.](https://aws.amazon.com/blogs/containers/migrating-from-aws-app-mesh-to-amazon-ecs-service-connect)
Este tópico ajuda você a usar AWS App Mesh com um serviço real que está sendo executado no Amazon EC2. Esse tutorial aborda os atributos básicos de vários tipos de recursos do App Mesh.
## Cenário
Para ilustrar como usar o App Mesh, suponha que você tenha um aplicativo com as seguintes características:
+ Consiste em dois serviços chamados `serviceA` e `serviceB`.
+ Ambos os serviços estão registrados em um namespace chamado `apps.local`.
+ O `ServiceA` se comunica com o `serviceB` por HTTP/2, porta 80.
+ Você já implantou a versão 2 do `serviceB` e a registrou com o nome de `serviceBv2` no namespace `apps.local`.
Você tem os seguintes requisitos:
+ Você quer enviar 75 por cento do tráfego de `serviceA` para `serviceB` e 25 por cento do tráfego para o `serviceBv2` primeiro. Ao enviar apenas 25% para`serviceBv2`, você pode validar que está livre de bugs antes de enviar 100% do tráfego de`serviceA`.
+ Você quer poder ajustar facilmente a ponderação do tráfego para que 100% do tráfego vá para o `serviceBv2` quando for comprovado que ele é confiável. Depois que todo o tráfego estiver sendo enviado para o `serviceBv2`, você deseja descontinuar o `serviceB`.
+ Você não quer ter que alterar nenhum código de aplicativo ou registro de descoberta de serviços existente para que seus serviços reais atendam aos requisitos anteriores.
Para atender às suas necessidades, você decide criar uma malha de serviços do App Mesh com serviços virtuais, nós virtuais, um roteador virtual e uma rota. Depois de implementar a malha, você atualiza os serviços que usam o proxy do Envoy. Assim que forem atualizados, os serviços se comunicarão entre si por meio do proxy Envoy em vez de diretamente entre si.
## Pré-requisitos
O App Mesh oferece suporte a serviços Linux registrados com DNS ou ambos. AWS Cloud Map Para usar este guia de conceitos básicos, recomendamos que você tenha três serviços existentes registrados no DNS. É possível criar uma malha de serviço e seus recursos mesmo que os serviços não existam, mas não será possível usar a malha enquanto não tiver implantado serviços reais.
Se ainda não tiver serviços em execução, você poderá iniciar instâncias do Amazon EC2 e implantar aplicativos nelas. Para obter mais informações, consulte [Tutorial: Introdução às instâncias Linux do Amazon EC2 no Guia](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-lamp-amazon-linux-2.html) do usuário do Amazon EC2. Supõe-se nas etapas restantes que os serviços reais sejam nomeados `serviceA`, `serviceB` e `serviceBv2` e que todos os serviços sejam detectáveis por meio de um namespace chamado `apps.local`.
## Etapa 1: Criar uma malha e um serviço virtual
Uma malha de serviços é um limite lógico para o tráfego de rede entre os serviços que residem nela. Para obter mais informações, consulte [Malhas de serviço](meshes.md). Um serviço virtual é uma abstração de um serviço real. Para obter mais informações, consulte [Serviços virtuais](virtual_services.md).
Crie os recursos da a seguir:
+ Uma malha chamada `apps`, uma vez que todos os serviços no cenário estão registrados no namespace `apps.local`.
+ Um serviço virtual chamado `serviceb.apps.local`, uma vez que o serviço virtual representa um serviço que é detectável com esse nome e você não quer alterar o código para fazer referência a outro nome. Um serviço virtual chamado `servicea.apps.local` será adicionado em uma etapa posterior.
Você pode usar a AWS CLI versão 1.18.116 Console de gerenciamento da AWS ou superior ou 2.0.38 ou superior para concluir as etapas a seguir. Se estiver usando o AWS CLI, use o `aws --version` comando para verificar sua AWS CLI versão instalada. Se você não tiver a versão 1.18.116 ou superior ou a versão 2.0.38 ou superior instalada, será necessário [instalar ou atualizar a AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/appmesh/cli-chap-install.html). Selecione a guia da ferramenta que deseja usar.
------
#### [ Console de gerenciamento da AWS ]
1. Abra o assistente de primeira execução do console App Mesh ao [https://console.aws.amazon.com/appmesh/começar](https://console.aws.amazon.com/appmesh/get-started).
1. Em **Mesh name (Nome da malha)**, insira **apps**.
1. Em **Virtual service name (Nome do serviço virtual)**, insira **serviceb.apps.local**.
1. Para continuar, escolha **Avançar**.
------
#### [ AWS CLI ]
1. Crie uma malha com o comando `[create-mesh](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-mesh.html)`.
```
aws appmesh create-mesh --mesh-name apps
```
1. Crie um serviço virtual com o comando `[create-virtual-service](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-virtual-service.html)`.
```
aws appmesh create-virtual-service --mesh-name apps --virtual-service-name serviceb.apps.local --spec {}
```
------
## Etapa 2: Criar um nó virtual
Um nó virtual funciona como um apontador lógico para um serviço real. Para obter mais informações, consulte [Nós virtuais](virtual_nodes.md).
Crie um nó virtual chamado `serviceB`, uma vez que um dos nós virtuais representa o serviço real chamado `serviceB`. O serviço real que o nó virtual representa é detectável por meio do `DNS` com um nome de host de `serviceb.apps.local`. Como alternativa, é possível descobrir serviços reais usando o AWS Cloud Map. O nó virtual recebe o tráfego usando o protocolo HTTP/2 na porta 80. Outros protocolos, assim como verificações de integridade, também são compatíveis. Você cria nós virtuais para `serviceA` e `serviceBv2` em uma etapa posterior.
------
#### [ Console de gerenciamento da AWS ]
1. Em **Virtual node name (Nome do nó virtual)**, insira **serviceB**.
1. Em **Service discovery method (Método de descoberta de serviços)**, escolha **DNS** e insira **serviceb.apps.local** para **DNS hostname (Nome de host do DNS)**.
1. Em **Listener configuration (Configuração do Listener)**, escolha **http2** para **Protocol (Protocolo)** e digite **80** para **Port (Porta)**.
1. Para continuar, escolha **Avançar**.
------
#### [ AWS CLI ]
1. Crie um arquivo denominado `create-virtual-node-serviceb.json` com o conteúdo a seguir:
```
{
"meshName": "apps",
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http2"
}
}
],
"serviceDiscovery": {
"dns": {
"hostname": "serviceB.apps.local"
}
}
},
"virtualNodeName": "serviceB"
}
```
1. Crie o nó virtual com o [create-virtual-node](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-virtual-node.html)comando usando o arquivo JSON como entrada.
```
aws appmesh create-virtual-node --cli-input-json file://create-virtual-node-serviceb.json
```
------
## Etapa 3: Criar um roteador virtual e uma rota
Os roteadores virtuais cuidam do tráfego de um ou mais serviços virtuais dentro da malha. Para obter mais informações, consulte [Roteadores virtuais](virtual_routers.md) e [Rotas](routes.md).
Crie os recursos da a seguir:
+ Um roteador virtual denominado `serviceB`, uma vez que o serviço virtual do `serviceB.apps.local` não inicia a comunicação de saída com nenhum outro serviço. Lembre-se de que o serviço virtual criado anteriormente é uma abstração do serviço `serviceb.apps.local` real. O serviço virtual envia tráfego para o roteador virtual. O roteador virtual recebe o tráfego usando o protocolo HTTP/2 na porta 80. Outros protocolos também são compatíveis.
+ Uma rota chamada `serviceB`. Ela roteia 100% de seu tráfego para o nó virtual do `serviceB`. O peso será alterado em uma etapa posterior, depois de adicionar o nó virtual do `serviceBv2`. Embora não seja abordado neste guia, é possível adicionar critérios de filtro adicionais para a rota e adicionar uma política de novas tentativas para fazer com que o proxy Envoy faça várias tentativas de enviar tráfego para um nó virtual quando ele tiver um problema de comunicação.
------
#### [ Console de gerenciamento da AWS ]
1. Em **Virtual router name (Nome do roteador virtual)**, insira **serviceB**.
1. Em **Listener configuration (Configuração do Listener)**, escolha **http2** para **Protocol (Protocolo)** e especifique **80** para **Port (Porta)**.
1. Em **Route name (Nome da rota)**, insira **serviceB**.
1. Em **Route type (Tipo de rota)**, escolha **http2**.
1. Para o **nome do nó virtual** em **Configuração de destino**, selecione `serviceB` e digite **100** para **Peso**.
1. Em **Configuração de correspondência**, escolha um **Método**.
1. Para continuar, escolha **Avançar**.
------
#### [ AWS CLI ]
1. Crie um roteador virtual.
1. Crie um arquivo denominado `create-virtual-router.json` com o conteúdo a seguir:
```
{
"meshName": "apps",
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http2"
}
}
]
},
"virtualRouterName": "serviceB"
}
```
1. Crie o roteador virtual com o [create-virtual-router](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-virtual-router.html)comando usando o arquivo JSON como entrada.
```
aws appmesh create-virtual-router --cli-input-json file://create-virtual-router.json
```
1. Crie uma rota.
1. Crie um arquivo denominado `create-route.json` com o conteúdo a seguir:
```
{
"meshName" : "apps",
"routeName" : "serviceB",
"spec" : {
"httpRoute" : {
"action" : {
"weightedTargets" : [
{
"virtualNode" : "serviceB",
"weight" : 100
}
]
},
"match" : {
"prefix" : "/"
}
}
},
"virtualRouterName" : "serviceB"
}
```
1. Crie a rota com o comando [create-route](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-route.html) usando o arquivo JSON como entrada.
```
aws appmesh create-route --cli-input-json file://create-route.json
```
------
## Etapa 4: revisar e criar
Revise as configurações em relação às instruções anteriores.
------
#### [ Console de gerenciamento da AWS ]
Se precisar fazer alterações em qualquer seção, selecione **Edit (Editar)**. Quando estiver satisfeito com as configurações, escolha **Create mesh (Criar malha)**.
A tela **Status** mostra todos os recursos de malha que foram criados. Você pode ver no console os recursos criados selecionando **View mesh (Exibir malha)**.
------
#### [ AWS CLI ]
Revise as configurações da malha criada com o comando [describe-mesh](https://docs.aws.amazon.com/cli/latest/reference/appmesh/describe-mesh.html).
```
aws appmesh describe-mesh --mesh-name apps
```
Revise as configurações do serviço virtual que você criou com o [describe-virtual-service](https://docs.aws.amazon.com/cli/latest/reference/appmesh/describe-virtual-service.html)comando.
```
aws appmesh describe-virtual-service --mesh-name apps --virtual-service-name serviceb.apps.local
```
Revise as configurações do nó virtual que você criou com o [describe-virtual-node](https://docs.aws.amazon.com/cli/latest/reference/appmesh/describe-virtual-node.html)comando.
```
aws appmesh describe-virtual-node --mesh-name apps --virtual-node-name serviceB
```
Revise as configurações do roteador virtual que você criou com o [describe-virtual-router](https://docs.aws.amazon.com/cli/latest/reference/appmesh/describe-virtual-router.html)comando.
```
aws appmesh describe-virtual-router --mesh-name apps --virtual-router-name serviceB
```
Revise as configurações da rota criada com o comando [describe-route](https://docs.aws.amazon.com/cli/latest/reference/appmesh/describe-route.html).
```
aws appmesh describe-route --mesh-name apps \
--virtual-router-name serviceB --route-name serviceB
```
------
## Etapa 5: Criar recursos adicionais
Para concluir o cenário, é necessário:
+ Criar um nó virtual chamado `serviceBv2` e outro chamado `serviceA`. Ambos os nós virtuais escutam solicitações por meio da porta 80 do HTTP/2. Para o nó virtual `serviceA`, configure um back-end do `serviceb.apps.local`. Todo o tráfego de saída do nó virtual `serviceA` é enviado para o serviço virtual chamado `serviceb.apps.local`. Embora não seja abordado neste guia, também é possível especificar um caminho de arquivo para gravar logs de acesso para um nó virtual.
+ Crie um serviço virtual adicional chamado `servicea.apps.local`, que enviará todo o tráfego diretamente para o nó virtual do `serviceA`.
+ Atualizar a rota do `serviceB` criada em uma etapa anterior para enviar 75% de seu tráfego para o nó virtual do `serviceB` e 25% de seu tráfego para o nó virtual do `serviceBv2`. Com o passar do tempo, você poderá continuar a modificar os pesos até que o `serviceBv2` receba 100% do tráfego. Depois que todo o tráfego for enviado para o `serviceBv2`, você poderá descontinuar o nó virtual do `serviceB` e o serviço real. Conforme você altera os pesos, o código não exigirá nenhuma modificação, porque os nomes de serviço `serviceb.apps.local` virtual e real não são alterados. Lembre-se de que o serviço virtual `serviceb.apps.local` envia tráfego para o roteador virtual, que roteia o tráfego para os nós virtuais. Os nomes de descoberta de serviço para os nós virtuais podem ser alterados a qualquer momento.
------
#### [ Console de gerenciamento da AWS ]
1. No painel de navegação à esquerda, selecione **Meshes (Malhas)**.
1. Selecione a malha `apps` criada em uma etapa anterior.
1. No painel de navegação esquerdo, selecione **Virtual nodes (Nós virtuais)**.
1. Selecione **Create nó virtual (Criar nó virtual)**.
1. Em **Virtual node name (Nome do nó virtual)**, insira **serviceBv2**, em **Service discovery method (Método de descoberta de serviço)**, escolha **DNS** e, em **DNS hostname (Nome de host do DNS)**, insira **servicebv2.apps.local**.
1. Em **Listener configuration (Configuração do Listener)**, selecione **http2** para **Protocol (Protocolo)** e digite **80** para **Port (Porta)**.
1. Selecione **Create nó virtual (Criar nó virtual)**.
1. Selecione **Create nó virtual (Criar nó virtual)** novamente. Digite **serviceA** para o o **Virtual node name (Nome do nó virtual)**. Em **Service discovery method (Método de descoberta de serviços)**, escolha **DNS** e, para **DNS hostname (Nome de host do DNS)**, insira **servicea.apps.local**.
1. Para **Enter a virtual service name (Digite um nome de serviço virtual)** em **New backend (Novo back-end)**, digite **serviceb.apps.local**.
1. Em **Listener configuration (Configuração do Listener)**, escolha **http2** para **Protocol (Protocolo)**, digite **80** para **Port (Porta)** e escolha **Create virtual node (Criar nó virtual)**.
1. No painel de navegação esquerdo, selecione **Virtual routers (Roteadores virtuais)** e, depois, selecione o roteador virtual `serviceB` na lista.
1. Em **Routes (Rotas)**, selecione a rota chamada `ServiceB` criada em uma etapa anterior e escolha **Edit (Editar)**.
1. Em **Targets (Destinos)**, **Virtual node name (Nome do nó virtual)**, altere o valor de **Weight (Peso)** de `serviceB` para **75**.
1. Escolha **Adicionar destino**, depois escolha `serviceBv2` na lista suspensa e defina o valor de **Peso** como **25**.
1. Escolha **Salvar**.
1. No painel de navegação esquerdo, selecione **Virtual services (Serviços virtuais)** e escolha **Create virtual service (Criar serviço virtual)**.
1. Insira **servicea.apps.local** para **Virtual service name (Nome do serviço virtual)**, selecione **Virtual node** para **Provider (Provedor)**, selecione `serviceA` para **Virtual node (Nó virtual)** e escolha **Create virtual service (Criar serviço virtual)**.
------
#### [ AWS CLI ]
1. Crie o nó virtual `serviceBv2`.
1. Crie um arquivo denominado `create-virtual-node-servicebv2.json` com o conteúdo a seguir:
```
{
"meshName": "apps",
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http2"
}
}
],
"serviceDiscovery": {
"dns": {
"hostname": "serviceBv2.apps.local"
}
}
},
"virtualNodeName": "serviceBv2"
}
```
1. Crie o nó virtual.
```
aws appmesh create-virtual-node --cli-input-json file://create-virtual-node-servicebv2.json
```
1. Crie o nó virtual `serviceA`.
1. Crie um arquivo denominado `create-virtual-node-servicea.json` com o conteúdo a seguir:
```
{
"meshName" : "apps",
"spec" : {
"backends" : [
{
"virtualService" : {
"virtualServiceName" : "serviceb.apps.local"
}
}
],
"listeners" : [
{
"portMapping" : {
"port" : 80,
"protocol" : "http2"
}
}
],
"serviceDiscovery" : {
"dns" : {
"hostname" : "servicea.apps.local"
}
}
},
"virtualNodeName" : "serviceA"
}
```
1. Crie o nó virtual.
```
aws appmesh create-virtual-node --cli-input-json file://create-virtual-node-servicea.json
```
1. Atualize o serviço virtual `serviceb.apps.local` criado em uma etapa anterior para enviar seu tráfego para o roteador virtual `serviceB`. Quando o serviço virtual foi criado originalmente, ele não enviava tráfego para nenhum lugar, já que o roteador virtual `serviceB` ainda não tinha sido criado.
1. Crie um arquivo denominado `update-virtual-service.json` com o conteúdo a seguir:
```
{
"meshName" : "apps",
"spec" : {
"provider" : {
"virtualRouter" : {
"virtualRouterName" : "serviceB"
}
}
},
"virtualServiceName" : "serviceb.apps.local"
}
```
1. Atualize o serviço virtual com o [update-virtual-service](https://docs.aws.amazon.com/cli/latest/reference/appmesh/update-virtual-service.html)comando.
```
aws appmesh update-virtual-service --cli-input-json file://update-virtual-service.json
```
1. Atualize a rota `serviceB` criada em uma etapa anterior.
1. Crie um arquivo denominado `update-route.json` com o conteúdo a seguir:
```
{
"meshName" : "apps",
"routeName" : "serviceB",
"spec" : {
"http2Route" : {
"action" : {
"weightedTargets" : [
{
"virtualNode" : "serviceB",
"weight" : 75
},
{
"virtualNode" : "serviceBv2",
"weight" : 25
}
]
},
"match" : {
"prefix" : "/"
}
}
},
"virtualRouterName" : "serviceB"
}
```
1. Atualize a rota com o comando [update-route](https://docs.aws.amazon.com/cli/latest/reference/appmesh/update-route.html).
```
aws appmesh update-route --cli-input-json file://update-route.json
```
1. Crie o serviço virtual `serviceA`.
1. Crie um arquivo denominado `create-virtual-servicea.json` com o conteúdo a seguir:
```
{
"meshName" : "apps",
"spec" : {
"provider" : {
"virtualNode" : {
"virtualNodeName" : "serviceA"
}
}
},
"virtualServiceName" : "servicea.apps.local"
}
```
1. Crie o serviço virtual.
```
aws appmesh create-virtual-service --cli-input-json file://create-virtual-servicea.json
```
------
**Resumo da malha**
Antes de criar a malha de serviço, você tinha três serviços reais chamados `servicea.apps.local`, `serviceb.apps.local` e `servicebv2.apps.local`. Além dos serviços reais, agora você tem uma malha de serviços que contém os seguintes recursos que representam os serviços reais:
+ Dois serviços virtuais. O proxy envia todo o tráfego do serviço virtual `servicea.apps.local` para o serviço virtual `serviceb.apps.local` por meio de um roteador virtual.
+ Três nós virtuais chamados `serviceA`, `serviceB` e `serviceBv2`. O proxy Envoy usa as informações de descoberta de serviço configuradas para os nós virtuais para pesquisar os endereços IP dos serviços reais.
+ Um roteador virtual com uma rota que instrui o proxy Envoy a rotear 75% do tráfego de entrada para o nó virtual `serviceB` e 25% do tráfego para o nó virtual `serviceBv2`.
## Etapa 6: Atualizar os serviços
Depois de criar a malha, é necessário concluir as seguintes tarefas:
+ Autorize o proxy Envoy implantado com cada serviço para ler a configuração de um ou mais nós virtuais. Para mais informações sobre como autorizar o proxy, consulte [Autorização do Envoy Proxy](proxy-authorization.md).
+ Para atualizar o serviço existente, conclua as etapas a seguir.
**Como configurar uma instância do Amazon EC2 como um membro de nó virtual**
1. Criar um perfil do IAM.
1. Crie um arquivo denominado `ec2-trust-relationship.json` com os conteúdos a seguir.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "ec2.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Crie um perfil do IAM com o comando a seguir.
```
aws iam create-role --role-name mesh-virtual-node-service-b --assume-role-policy-document file://ec2-trust-relationship.json
```
1. Anexe políticas do IAM ao perfil que lhe permitam ler do Amazon ECR e apenas a configuração de um nó virtual do App Mesh específico.
1. Crie um arquivo denominado `virtual-node-policy.json` com o conteúdo a seguir. `apps` é o nome da malha que você criou em [Etapa 1: Criar uma malha e um serviço virtual](#create-mesh-and-virtual-service) e `serviceB` é o nome do nó virtual que você criou em [Etapa 2: Criar um nó virtual](#create-virtual-node). *111122223333*Substitua pelo ID da sua conta e *us-west-2* pela região em que você criou sua malha.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "appmesh:StreamAggregatedResources",
"Resource": [
"arn:aws:appmesh:us-west-2:111122223333:mesh/apps/virtualNode/serviceB"
]
}
]
}
```
------
1. Crie a política com o comando a seguir.
```
aws iam create-policy --policy-name virtual-node-policy --policy-document file://virtual-node-policy.json
```
1. Anexe a política que você criou na etapa anterior ao perfil para que ele possa ler a configuração somente para o nó virtual de `serviceB` no App Mesh.
```
aws iam attach-role-policy --policy-arn arn:aws:iam::111122223333:policy/virtual-node-policy --role-name mesh-virtual-node-service-b
```
1. Anexe a política gerenciada `AmazonEC2ContainerRegistryReadOnly` ao perfil para que ele possa extrair a imagem do contêiner Envoy do Amazon ECR.
```
aws iam attach-role-policy --policy-arn arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryReadOnly --role-name mesh-virtual-node-service-b
```
1. [Inicie uma instância do Amazon EC2 com o perfil do IAM](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#launch-instance-with-role) que você criou.
1. Conecte-se à instância via SSH.
1. Instale o Docker e o AWS CLI na sua instância de acordo com a documentação do sistema operacional.
1. Autentique-se no repositório do Amazon ECR do Envoy na região da qual você deseja que seu cliente Docker obtenha a imagem.
+ Todas as regiões, exceto `me-south-1`, `ap-east-1`, `ap-southeast-3`, `eu-south-1`, `il-central-1` e `af-south-1`. Você pode *us-west-2* substituir por qualquer [região compatível](https://docs.aws.amazon.com/general/latest/gr/appmesh.html)`me-south-1`, exceto `ap-east-1``ap-southeast-3`,`eu-south-1`,`il-central-1`,, `af-south-1` e.
```
$aws ecr get-login-password \
--region us-west-2 \
| docker login \
--username AWS \
--password-stdin 840364872350.dkr.ecr.us-west-2.amazonaws.com
```
+ Região `me-south-1`
```
$aws ecr get-login-password \
--region me-south-1 \
| docker login \
--username AWS \
--password-stdin 772975370895.dkr.ecr.me-south-1.amazonaws.com
```
+ Região da `ap-east-1`
```
$aws ecr get-login-password \
--region ap-east-1 \
| docker login \
--username AWS \
--password-stdin 856666278305.dkr.ecr.ap-east-1.amazonaws.com
```
1. Execute um dos seguintes comandos para iniciar o contêiner do App Mesh Envoy na sua instância, dependendo de qual Região você queira obter a imagem. Os *serviceB* valores *apps* e são os nomes dos nós virtuais e da malha definidos no cenário. Esses dados informam o proxy sobre a configuração de nó virtual a ser lida no App Mesh. Para concluir o cenário, também é necessário concluir essas etapas para as instâncias do EC2 que hospedam os serviços representados pelos nós virtuais `serviceBv2` e `serviceA`. Para os aplicativos, substitua esses valores pelos seus próprios.
+ Todas as regiões, exceto `me-south-1`, `ap-east-1`, `ap-southeast-3`, `eu-south-1`, `il-central-1` e `af-south-1`. Você pode *Region-code* substituir por qualquer [região compatível](https://docs.aws.amazon.com/general/latest/gr/appmesh.html)`me-south-1`, exceto as `af-south-1` regiões `ap-east-1``ap-southeast-3`,`eu-south-1`,`il-central-1`,, e. Você pode substituir `1337` por qualquer valor entre `0` e `2147483647`.
```
sudo docker run --detach --env APPMESH_RESOURCE_ARN=mesh/apps/virtualNode/serviceB \
-u 1337 --network host 840364872350.dkr.ecr.region-code.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
+ Região `me-south-1`. Você pode substituir `1337` por qualquer valor entre `0` e `2147483647`.
```
sudo docker run --detach --env APPMESH_RESOURCE_ARN=mesh/apps/virtualNode/serviceB \
-u 1337 --network host 772975370895.dkr.ecr.me-south-1.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
+ Região `ap-east-1`. Você pode substituir `1337` por qualquer valor entre `0` e `2147483647`.
```
sudo docker run --detach --env APPMESH_RESOURCE_ARN=mesh/apps/virtualNode/serviceB \
-u 1337 --network host 856666278305.dkr.ecr.ap-east-1.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
**nota**
A propriedade `APPMESH_RESOURCE_ARN` requer uma versão `1.15.0` ou posterior da imagem do Envoy. Para obter mais informações, consulte [Imagem do Envoy](envoy.md).
**Importante**
Somente a versão v1.9.0.0-prod ou posterior é compatível para uso com o App Mesh.
1. Selecione `Show more` abaixo. Crie em sua instância um arquivo denominado `envoy-networking.sh` com os conteúdos a seguir. *8000*Substitua pela porta que o código do aplicativo usa para o tráfego de entrada. Você pode alterar o valor para `APPMESH_IGNORE_UID`, mas o valor deve ser o mesmo que o valor especificado na etapa anterior, por exemplo, `1337`. Se necessário, você pode incluir endereços adicionais ao `APPMESH_EGRESS_IGNORED_IP`. Não modifique nenhuma outra linha.
```
#!/bin/bash -e
#
# Start of configurable options
#
#APPMESH_START_ENABLED="0"
APPMESH_IGNORE_UID="1337"
APPMESH_APP_PORTS="8000"
APPMESH_ENVOY_EGRESS_PORT="15001"
APPMESH_ENVOY_INGRESS_PORT="15000"
APPMESH_EGRESS_IGNORED_IP="169.254.169.254,169.254.170.2"
# Enable routing on the application start.
[ -z "$APPMESH_START_ENABLED" ] && APPMESH_START_ENABLED="0"
# Enable IPv6.
[ -z "$APPMESH_ENABLE_IPV6" ] && APPMESH_ENABLE_IPV6="0"
# Egress traffic from the processess owned by the following UID/GID will be ignored.
if [ -z "$APPMESH_IGNORE_UID" ] && [ -z "$APPMESH_IGNORE_GID" ]; then
echo "Variables APPMESH_IGNORE_UID and/or APPMESH_IGNORE_GID must be set."
echo "Envoy must run under those IDs to be able to properly route it's egress traffic."
exit 1
fi
# Port numbers Application and Envoy are listening on.
if [ -z "$APPMESH_ENVOY_EGRESS_PORT" ]; then
echo "APPMESH_ENVOY_EGRESS_PORT must be defined to forward traffic from the application to the proxy."
exit 1
fi
# If an app port was specified, then we also need to enforce the proxies ingress port so we know where to forward traffic.
if [ ! -z "$APPMESH_APP_PORTS" ] && [ -z "$APPMESH_ENVOY_INGRESS_PORT" ]; then
echo "APPMESH_ENVOY_INGRESS_PORT must be defined to forward traffic from the APPMESH_APP_PORTS to the proxy."
exit 1
fi
# Comma separated list of ports for which egress traffic will be ignored, we always refuse to route SSH traffic.
if [ -z "$APPMESH_EGRESS_IGNORED_PORTS" ]; then
APPMESH_EGRESS_IGNORED_PORTS="22"
else
APPMESH_EGRESS_IGNORED_PORTS="$APPMESH_EGRESS_IGNORED_PORTS,22"
fi
#
# End of configurable options
#
function initialize() {
echo "=== Initializing ==="
if [ ! -z "$APPMESH_APP_PORTS" ]; then
iptables -t nat -N APPMESH_INGRESS
if [ "$APPMESH_ENABLE_IPV6" == "1" ]; then
ip6tables -t nat -N APPMESH_INGRESS
fi
fi
iptables -t nat -N APPMESH_EGRESS
if [ "$APPMESH_ENABLE_IPV6" == "1" ]; then
ip6tables -t nat -N APPMESH_EGRESS
fi
}
function enable_egress_routing() {
# Stuff to ignore
[ ! -z "$APPMESH_IGNORE_UID" ] && \
iptables -t nat -A APPMESH_EGRESS \
-m owner --uid-owner $APPMESH_IGNORE_UID \
-j RETURN
[ ! -z "$APPMESH_IGNORE_GID" ] && \
iptables -t nat -A APPMESH_EGRESS \
-m owner --gid-owner $APPMESH_IGNORE_GID \
-j RETURN
[ ! -z "$APPMESH_EGRESS_IGNORED_PORTS" ] && \
for IGNORED_PORT in $(echo "$APPMESH_EGRESS_IGNORED_PORTS" | tr "," "\n"); do
iptables -t nat -A APPMESH_EGRESS \
-p tcp \
-m multiport --dports "$IGNORED_PORT" \
-j RETURN
done
if [ "$APPMESH_ENABLE_IPV6" == "1" ]; then
# Stuff to ignore ipv6
[ ! -z "$APPMESH_IGNORE_UID" ] && \
ip6tables -t nat -A APPMESH_EGRESS \
-m owner --uid-owner $APPMESH_IGNORE_UID \
-j RETURN
[ ! -z "$APPMESH_IGNORE_GID" ] && \
ip6tables -t nat -A APPMESH_EGRESS \
-m owner --gid-owner $APPMESH_IGNORE_GID \
-j RETURN
[ ! -z "$APPMESH_EGRESS_IGNORED_PORTS" ] && \
for IGNORED_PORT in $(echo "$APPMESH_EGRESS_IGNORED_PORTS" | tr "," "\n"); do
ip6tables -t nat -A APPMESH_EGRESS \
-p tcp \
-m multiport --dports "$IGNORED_PORT" \
-j RETURN
done
fi
# The list can contain both IPv4 and IPv6 addresses. We will loop over this list
# to add every IPv4 address into `iptables` and every IPv6 address into `ip6tables`.
[ ! -z "$APPMESH_EGRESS_IGNORED_IP" ] && \
for IP_ADDR in $(echo "$APPMESH_EGRESS_IGNORED_IP" | tr "," "\n"); do
if [[ $IP_ADDR =~ .*:.* ]]
then
[ "$APPMESH_ENABLE_IPV6" == "1" ] && \
ip6tables -t nat -A APPMESH_EGRESS \
-p tcp \
-d "$IP_ADDR" \
-j RETURN
else
iptables -t nat -A APPMESH_EGRESS \
-p tcp \
-d "$IP_ADDR" \
-j RETURN
fi
done
# Redirect everything that is not ignored
iptables -t nat -A APPMESH_EGRESS \
-p tcp \
-j REDIRECT --to $APPMESH_ENVOY_EGRESS_PORT
# Apply APPMESH_EGRESS chain to non local traffic
iptables -t nat -A OUTPUT \
-p tcp \
-m addrtype ! --dst-type LOCAL \
-j APPMESH_EGRESS
if [ "$APPMESH_ENABLE_IPV6" == "1" ]; then
# Redirect everything that is not ignored ipv6
ip6tables -t nat -A APPMESH_EGRESS \
-p tcp \
-j REDIRECT --to $APPMESH_ENVOY_EGRESS_PORT
# Apply APPMESH_EGRESS chain to non local traffic ipv6
ip6tables -t nat -A OUTPUT \
-p tcp \
-m addrtype ! --dst-type LOCAL \
-j APPMESH_EGRESS
fi
}
function enable_ingress_redirect_routing() {
# Route everything arriving at the application port to Envoy
iptables -t nat -A APPMESH_INGRESS \
-p tcp \
-m multiport --dports "$APPMESH_APP_PORTS" \
-j REDIRECT --to-port "$APPMESH_ENVOY_INGRESS_PORT"
# Apply AppMesh ingress chain to everything non-local
iptables -t nat -A PREROUTING \
-p tcp \
-m addrtype ! --src-type LOCAL \
-j APPMESH_INGRESS
if [ "$APPMESH_ENABLE_IPV6" == "1" ]; then
# Route everything arriving at the application port to Envoy ipv6
ip6tables -t nat -A APPMESH_INGRESS \
-p tcp \
-m multiport --dports "$APPMESH_APP_PORTS" \
-j REDIRECT --to-port "$APPMESH_ENVOY_INGRESS_PORT"
# Apply AppMesh ingress chain to everything non-local ipv6
ip6tables -t nat -A PREROUTING \
-p tcp \
-m addrtype ! --src-type LOCAL \
-j APPMESH_INGRESS
fi
}
function enable_routing() {
echo "=== Enabling routing ==="
enable_egress_routing
if [ ! -z "$APPMESH_APP_PORTS" ]; then
enable_ingress_redirect_routing
fi
}
function disable_routing() {
echo "=== Disabling routing ==="
iptables -t nat -F APPMESH_INGRESS
iptables -t nat -F APPMESH_EGRESS
if [ "$APPMESH_ENABLE_IPV6" == "1" ]; then
ip6tables -t nat -F APPMESH_INGRESS
ip6tables -t nat -F APPMESH_EGRESS
fi
}
function dump_status() {
echo "=== iptables FORWARD table ==="
iptables -L -v -n
echo "=== iptables NAT table ==="
iptables -t nat -L -v -n
if [ "$APPMESH_ENABLE_IPV6" == "1" ]; then
echo "=== ip6tables FORWARD table ==="
ip6tables -L -v -n
echo "=== ip6tables NAT table ==="
ip6tables -t nat -L -v -n
fi
}
function clean_up() {
disable_routing
ruleNum=$(iptables -L PREROUTING -t nat --line-numbers | grep APPMESH_INGRESS | cut -d " " -f 1)
iptables -t nat -D PREROUTING $ruleNum
ruleNum=$(iptables -L OUTPUT -t nat --line-numbers | grep APPMESH_EGRESS | cut -d " " -f 1)
iptables -t nat -D OUTPUT $ruleNum
iptables -t nat -X APPMESH_INGRESS
iptables -t nat -X APPMESH_EGRESS
if [ "$APPMESH_ENABLE_IPV6" == "1" ]; then
ruleNum=$(ip6tables -L PREROUTING -t nat --line-numbers | grep APPMESH_INGRESS | cut -d " " -f 1)
ip6tables -t nat -D PREROUTING $ruleNum
ruleNum=$(ip6tables -L OUTPUT -t nat --line-numbers | grep APPMESH_EGRESS | cut -d " " -f 1)
ip6tables -t nat -D OUTPUT $ruleNum
ip6tables -t nat -X APPMESH_INGRESS
ip6tables -t nat -X APPMESH_EGRESS
fi
}
function main_loop() {
echo "=== Entering main loop ==="
while read -p '> ' cmd; do
case "$cmd" in
"quit")
clean_up
break
;;
"status")
dump_status
;;
"enable")
enable_routing
;;
"disable")
disable_routing
;;
*)
echo "Available commands: quit, status, enable, disable"
;;
esac
done
}
function print_config() {
echo "=== Input configuration ==="
env | grep APPMESH_ || true
}
print_config
initialize
if [ "$APPMESH_START_ENABLED" == "1" ]; then
enable_routing
fi
main_loop
```
1. Para configurar regras de `iptables` para rotear o tráfego do aplicativo para o proxy Envoy, execute o script que você criou na etapa anterior.
```
sudo ./envoy-networking.sh
```
1. Inicie o código do aplicativo do nó virtual.
**nota**
Para ver mais exemplos e orientações sobre o App Mesh, consulte o [repositório de exemplos do App Mesh](https://github.com/aws/aws-app-mesh-examples).