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á.
# Conceitos básicos do App Mesh
**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)
Você pode usar o App Mesh com aplicativos que você implanta no Amazon ECS, Kubernetes (que você implanta em suas próprias instâncias do Amazon EC2 ou executados no Amazon EKS) e Amazon EC2. Para começar a usar o App Mesh, selecione um dos serviços nos quais você tem aplicativos implantados e que deseja usar com o App Mesh. Você sempre pode permitir que aplicativos em outros serviços também funcionem com o App Mesh depois de concluir um dos guias de conceitos básicos.
**Topics**
+ [Começando a usar AWS App Mesh o Amazon ECS](getting-started-ecs.md)
+ [Introdução ao AWS App Mesh Kubernetes](getting-started-kubernetes.md)
+ [Começando a usar AWS App Mesh o Amazon EC2](getting-started-ec2.md)
+ [Exemplos do App Mesh](examples.md)
# Começando a usar AWS App Mesh o Amazon ECS
**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 ECS. 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
**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)
+ Uma compreensão existente dos conceitos do App Mesh. Para obter mais informações, consulte [O que é AWS App Mesh?](what-is-app-mesh.md).
+ Uma compreensão existente dos ECSs conceitos da Amazon. Para obter mais informações, consulte [O que é o Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html) no Guia do desenvolvedor do Amazon Elastic Container Service.
+ 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. Para os procedimentos nesse tópico, espera-se que os serviços existentes sejam nomeados `serviceA`, `serviceB` e `serviceBv2`; e que todos os serviços sejam detectáveis por meio de um namespace chamado `apps.local`.
É 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. Para mais informações sobre a descoberta de serviços no Amazon ECS, consulte [Descoberta de serviços](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-discovery.html). Para criar um serviço do Amazon ECS com descoberta de serviços, consulte [Tutorial: Como criar um serviço usando a descoberta de serviços](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service-discovery.html). Se você ainda não tem serviços em execução, você pode [Criar um serviço Amazon ECS com a descoberta de serviços](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service-discovery.html).
## 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, você pode descobrir serviços reais usando. AWS Cloud Map O nó virtual escutará 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ê criará 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 tarefa do Amazon ECS para ler a configuração de um ou mais nós virtuais. Para mais informações sobre como autorizar o proxy, consulte [Autorização de proxy](https://docs.aws.amazon.com/app-mesh/latest/userguide/proxy-authorization.html).
+ Atualize cada uma das definições de tarefa do Amazon ECS existentes para usar o proxy Envoy.
**Credenciais**
O contêiner Envoy exige AWS Identity and Access Management credenciais para assinar solicitações que são enviadas ao serviço App Mesh. Para tarefas do Amazon ECS implantadas com o tipo de execução do Amazon EC2, as credenciais podem vir da [função da instância](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/instance_IAM_role.html) ou de um [perfil do IAM da tarefa](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html). As tarefas do Amazon ECS implantadas com o Fargate em contêineres Linux não têm acesso ao servidor de metadados do Amazon EC2 que fornece credenciais de perfil do IAM da instância. Para fornecer as credenciais, você deve associar uma função de tarefa do IAM a qualquer tarefa implantada com o Fargate no tipo de contêiner Linux.
Se uma tarefa for implantada com o tipo de inicialização do Amazon EC2 e o acesso for bloqueado para o servidor de metadados do Amazon EC2, conforme descrito na anotação *Importante* em [Perfil do IAM para tarefas](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html), um perfil do IAM de tarefa também deverá ser associada à tarefa. A função que você atribui à instância ou à tarefa deve ter uma política do IAM anexada a ela, conforme descrito em [Autorização de proxy](https://docs.aws.amazon.com/app-mesh/latest/userguide/proxy-authorization.html).
**Para atualizar sua definição de tarefa usando o AWS CLI**
Você usa o AWS CLI comando [https://docs.aws.amazon.com/cli/latest/reference/ecs/register-task-definition.html](https://docs.aws.amazon.com/cli/latest/reference/ecs/register-task-definition.html)Amazon ECS. O exemplo de definição de tarefa abaixo mostra como configurar o App Mesh para seu serviço.
**nota**
A configuração do App Mesh para o Amazon ECS por meio do console não está disponível.
### Json da definição de tarefas
**Configuração do proxy**
Para configurar seu serviço do Amazon ECS para usar o App Mesh, a definição de tarefa do serviço deverá ter a seção de configuração de proxy a seguir. Defina a configuração de proxy `type` como `APPMESH` e `containerName` como `envoy`. Defina os seguintes valores de propriedade da maneira adequada.
`IgnoredUID`
O proxy Envoy não roteia o tráfego de processos que usam esse ID de usuário. É possível escolher qualquer ID de usuário que você quiser para esse valor de propriedade, mas esse ID deve ser o mesmo que o ID de `user` do contêiner do Envoy na definição de tarefa. Essa correspondência permite que o Envoy ignore seu próprio tráfego sem usar o proxy. Nossos exemplos usam `1337` para fins históricos.
`ProxyIngressPort`
Essa é a porta de entrada para o contêiner do proxy Envoy. Defina este valor como `15000`.
`ProxyEgressPort`
Essa é a porta de saída para o contêiner do proxy Envoy. Defina este valor como `15001`.
`AppPorts`
Especifique as portas de entrada em que seus contêineres de aplicativos recebem. Neste exemplo, o contêiner do aplicativo escuta na porta `9080`. A porta especificada deve corresponder à porta configurada no listener do nó virtual.
`EgressIgnoredIPs`
O Envoy não faz a intermediação do tráfego para esses endereços IP. Defina esse valor como `169.254.170.2,169.254.169.254`, que ignora o servidor de metadados do EC2 e o endpoint de metadados da tarefa do ECS. O endpoint de metadados fornece perfis do IAM para credenciais de tarefas. É possível adicionar outros endereços.
`EgressIgnoredPorts`
É possível adicionar uma lista de portas separada por vírgulas. O Envoy não faz a intermediação do tráfego para essas portas. Mesmo que você não liste nenhuma porta, a porta 22 será ignorada.
O número máximo de portas de saída que podem ser ignoradas é 15.
```
"proxyConfiguration": {
"type": "APPMESH",
"containerName": "envoy",
"properties": [{
"name": "IgnoredUID",
"value": "1337"
},
{
"name": "ProxyIngressPort",
"value": "15000"
},
{
"name": "ProxyEgressPort",
"value": "15001"
},
{
"name": "AppPorts",
"value": "9080"
},
{
"name": "EgressIgnoredIPs",
"value": "169.254.170.2,169.254.169.254"
},
{
"name": "EgressIgnoredPorts",
"value": "22"
}
]
}
```
**Dependência de contêiner de aplicativos do Envoy**
Os contêineres de aplicativos em suas definições de tarefas devem aguardar o bootstrap e o início do proxy Envoy para que possam ser iniciados. Para garantir que isso aconteça, você define uma seção `dependsOn` em cada definição de contêiner de aplicativos para aguardar que o contêiner do Envoy seja relatado como `HEALTHY`. O código a seguir mostra um exemplo de definição de contêiner de aplicativos com essa dependência. Todas as propriedades no exemplo a seguir são necessárias. Alguns dos valores da propriedade também são obrigatórios, mas alguns são*replaceable*.
```
{
"name": "appName",
"image": "appImage",
"portMappings": [{
"containerPort": 9080,
"hostPort": 9080,
"protocol": "tcp"
}],
"essential": true,
"dependsOn": [{
"containerName": "envoy",
"condition": "HEALTHY"
}]
}
```
**Definição de contêiner do Envoy**
Suas definições de tarefas do Amazon ECS devem conter uma imagem de contêiner do App Mesh Envoy.
Todas as regiões [suportadas](https://docs.aws.amazon.com/general/latest/gr/appmesh.html) podem ser *Region-code* substituídas por qualquer região que não seja `me-south-1` `ap-east-1``ap-southeast-3`,`eu-south-1`,`il-central-1`,, `af-south-1` e.
Standard
```
840364872350.dkr.ecr.region-code.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
Compatível com FIPS
```
840364872350.dkr.ecr.region-code.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod-fips
```
`me-south-1`
Standard
```
772975370895.dkr.ecr.me-south-1.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
`ap-east-1`
Standard
```
856666278305.dkr.ecr.ap-east-1.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
`ap-southeast-3`
Standard
```
909464085924.dkr.ecr.ap-southeast-3.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
`eu-south-1`
Standard
```
422531588944.dkr.ecr.eu-south-1.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
`il-central-1`
Standard
```
564877687649.dkr.ecr.il-central-1.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
`af-south-1`
Standard
```
924023996002.dkr.ecr.af-south-1.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
`Public repository`
Standard
```
public.ecr.aws/appmesh/aws-appmesh-envoy:v1.34.13.0-prod
```
Compatível com FIPS
```
public.ecr.aws/appmesh/aws-appmesh-envoy:v1.34.13.0-prod-fips
```
**Importante**
Somente a versão v1.9.0.0-prod ou posterior é compatível para uso com o App Mesh.
Você deve usar a imagem do contêiner do App Mesh Envoy até que a equipe do projeto Envoy mescle as alterações compatíveis com o App Mesh. Para obter detalhes adicionais, consulte a [edição do GitHub roteiro](https://github.com/aws/aws-app-mesh-roadmap/issues/10).
Todas as propriedades no exemplo a seguir são necessárias. Alguns dos valores da propriedade também são obrigatórios, mas alguns são*replaceable*.
**nota**
A definição de contêiner do Envoy deve ser marcada como `essential`.
Recomendamos a alocação de `512` unidades de CPU e pelo menos `64` MiB de memória para o contêiner do Envoy. No Fargate, o mínimo que você poderá definir é `1024` MiB de memória.
O nome do nó virtual para o serviço do Amazon ECS deve ser definido como o valor da propriedade `APPMESH_RESOURCE_ARN`. Essa propriedade requer uma versão `1.15.0` ou posterior da imagem do Envoy. Para obter mais informações, consulte [Imagem do Envoy](envoy.md).
O valor da configuração de `user` deve corresponder ao valor `IgnoredUID` da configuração de proxy da definição de tarefa. Neste exemplo, usamos `1337`.
A verificação de integridade mostrada aqui aguarda o contêiner do Envoy ser inicializado corretamente antes de relatar ao Amazon ECS que o contêiner do Envoy está íntegro e pronto para que os contêineres de aplicativos sejam iniciados.
Por padrão, o App Mesh usa o nome do recurso especificado em `APPMESH_RESOURCE_ARN` quando o Envoy está se referindo a si mesmo em métricas e rastreamentos. É possível substituir esse comportamento definindo a variável de ambiente `APPMESH_RESOURCE_CLUSTER` com seu próprio nome. Essa propriedade requer uma versão `1.15.0` ou posterior da imagem do Envoy. Para obter mais informações, consulte [Imagem do Envoy](envoy.md).
O código a seguir mostra um exemplo de definição de contêiner do Envoy.
```
{
"name": "envoy",
"image": "840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod",
"essential": true,
"environment": [{
"name": "APPMESH_RESOURCE_ARN",
"value": "arn:aws:appmesh:us-west-2:111122223333:mesh/apps/virtualNode/serviceB"
}],
"healthCheck": {
"command": [
"CMD-SHELL",
"curl -s http://localhost:9901/server_info | grep state | grep -q LIVE"
],
"startPeriod": 10,
"interval": 5,
"timeout": 2,
"retries": 3
},
"user": "1337"
}
```
**Exemplos de definições de tarefa**
O exemplo de definições de tarefa do Amazon ECS a seguir mostra como mesclar os exemplos acima em uma definição de tarefa para `taskB`. São fornecidos exemplos de criação de tarefas para ambos os tipos de inicialização do Amazon ECS, com ou sem o uso do AWS X-Ray. Altere os *replaceable* valores, conforme apropriado, para criar definições de tarefas para as tarefas nomeadas `taskBv2` e `taskA` do cenário. Substitua o nome da malha e o nome do nó virtual pelo valor `APPMESH_RESOURCE_ARN` e uma lista de portas em que seu aplicativo escuta pelo valor `AppPorts` da configuração de proxy. Por padrão, o App Mesh usa o nome do recurso especificado em `APPMESH_RESOURCE_ARN` quando o Envoy está se referindo a si mesmo em métricas e rastreamentos. É possível substituir esse comportamento definindo a variável de ambiente `APPMESH_RESOURCE_CLUSTER` com seu próprio nome. Todas as propriedades nos exemplos a seguir são necessárias. Alguns dos valores da propriedade também são obrigatórios, mas alguns são*replaceable*.
Se você estiver executando uma tarefa do Amazon ECS conforme descrito na seção Credenciais, será necessário adicionar um [perfil do IAM de tarefa](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) existente aos exemplos.
**Importante**
O Fargate deve usar um valor de porta maior que 1024.
**Example JSON para definição de tarefas do Amazon ECS: Fargate em contêineres Linux**
```
{
"family" : "taskB",
"memory" : "1024",
"cpu" : "0.5 vCPU",
"proxyConfiguration" : {
"containerName" : "envoy",
"properties" : [
{
"name" : "ProxyIngressPort",
"value" : "15000"
},
{
"name" : "AppPorts",
"value" : "9080"
},
{
"name" : "EgressIgnoredIPs",
"value" : "169.254.170.2,169.254.169.254"
},
{
"name": "EgressIgnoredPorts",
"value": "22"
},
{
"name" : "IgnoredUID",
"value" : "1337"
},
{
"name" : "ProxyEgressPort",
"value" : "15001"
}
],
"type" : "APPMESH"
},
"containerDefinitions" : [
{
"name" : "appName",
"image" : "appImage",
"portMappings" : [
{
"containerPort" : 9080,
"protocol" : "tcp"
}
],
"essential" : true,
"dependsOn" : [
{
"containerName" : "envoy",
"condition" : "HEALTHY"
}
]
},
{
"name" : "envoy",
"image" : "840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod",
"essential" : true,
"environment" : [
{
"name" : "APPMESH_VIRTUAL_NODE_NAME",
"value" : "mesh/apps/virtualNode/serviceB"
}
],
"healthCheck" : {
"command" : [
"CMD-SHELL",
"curl -s http://localhost:9901/server_info | grep state | grep -q LIVE"
],
"interval" : 5,
"retries" : 3,
"startPeriod" : 10,
"timeout" : 2
},
"memory" : 500,
"user" : "1337"
}
],
"requiresCompatibilities" : [ "FARGATE" ],
"taskRoleArn" : "arn:aws:iam::123456789012:role/ecsTaskRole",
"executionRoleArn" : "arn:aws:iam::123456789012:role/ecsTaskExecutionRole",
"networkMode" : "awsvpc"
}
```
**Example Definição de tarefas JSON para Amazon ECS com - AWS X-Ray Fargate em contêineres Linux**
O X-Ray permite que você colete dados sobre solicitações que um aplicativo atende e fornece ferramentas que você pode usar para visualizar o fluxo de tráfego. O uso do driver X-Ray para Envoy permite que o Envoy relate informações de rastreamento ao X-Ray. Para habilitar o rastreamento do X-Ray, use a [configuração do Envoy](https://docs.aws.amazon.com/app-mesh/latest/userguide/envoy.html). Com base na configuração, o Envoy envia dados de rastreamento para o daemon do X-Ray em execução como um contêiner [sidecar](https://docs.aws.amazon.com/xray/latest/devguide/xray-daemon-ecs.html), e o daemon encaminha os rastreamentos para o serviço X-Ray. Assim que os rastreamentos são publicados no X-Ray, você pode usar o console do X-Ray para visualizar o gráfico de chamada de serviço e solicitar detalhes de rastreamento. O seguinte JSON representa uma definição de tarefa para habilitar a integração do X-Ray.
```
{
"family" : "taskB",
"memory" : "1024",
"cpu" : "512",
"proxyConfiguration" : {
"containerName" : "envoy",
"properties" : [
{
"name" : "ProxyIngressPort",
"value" : "15000"
},
{
"name" : "AppPorts",
"value" : "9080"
},
{
"name" : "EgressIgnoredIPs",
"value" : "169.254.170.2,169.254.169.254"
},
{
"name": "EgressIgnoredPorts",
"value": "22"
},
{
"name" : "IgnoredUID",
"value" : "1337"
},
{
"name" : "ProxyEgressPort",
"value" : "15001"
}
],
"type" : "APPMESH"
},
"containerDefinitions" : [
{
"name" : "appName",
"image" : "appImage",
"portMappings" : [
{
"containerPort" : 9080,
"protocol" : "tcp"
}
],
"essential" : true,
"dependsOn" : [
{
"containerName" : "envoy",
"condition" : "HEALTHY"
}
]
},
{
"name" : "envoy",
"image" : "840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod",
"essential" : true,
"environment" : [
{
"name" : "APPMESH_VIRTUAL_NODE_NAME",
"value" : "mesh/apps/virtualNode/serviceB"
},
{
"name": "ENABLE_ENVOY_XRAY_TRACING",
"value": "1"
}
],
"healthCheck" : {
"command" : [
"CMD-SHELL",
"curl -s http://localhost:9901/server_info | grep state | grep -q LIVE"
],
"interval" : 5,
"retries" : 3,
"startPeriod" : 10,
"timeout" : 2
},
"memory" : 500,
"user" : "1337"
},
{
"name" : "xray-daemon",
"image" : "amazon/aws-xray-daemon",
"user" : "1337",
"essential" : true,
"cpu" : "32",
"memoryReservation" : "256",
"portMappings" : [
{
"containerPort" : 2000,
"protocol" : "udp"
}
]
}
],
"requiresCompatibilities" : [ "FARGATE" ],
"taskRoleArn" : "arn:aws:iam::123456789012:role/ecsTaskRole",
"executionRoleArn" : "arn:aws:iam::123456789012:role/ecsTaskExecutionRole",
"networkMode" : "awsvpc"
}
```
**Example JSON para definição de tarefa do Amazon ECS: tipo de inicialização do EC2**
```
{
"family": "taskB",
"memory": "256",
"proxyConfiguration": {
"type": "APPMESH",
"containerName": "envoy",
"properties": [
{
"name": "IgnoredUID",
"value": "1337"
},
{
"name": "ProxyIngressPort",
"value": "15000"
},
{
"name": "ProxyEgressPort",
"value": "15001"
},
{
"name": "AppPorts",
"value": "9080"
},
{
"name": "EgressIgnoredIPs",
"value": "169.254.170.2,169.254.169.254"
},
{
"name": "EgressIgnoredPorts",
"value": "22"
}
]
},
"containerDefinitions": [
{
"name": "appName",
"image": "appImage",
"portMappings": [
{
"containerPort": 9080,
"hostPort": 9080,
"protocol": "tcp"
}
],
"essential": true,
"dependsOn": [
{
"containerName": "envoy",
"condition": "HEALTHY"
}
]
},
{
"name": "envoy",
"image": "840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod",
"essential": true,
"environment": [
{
"name": "APPMESH_VIRTUAL_NODE_NAME",
"value": "mesh/apps/virtualNode/serviceB"
}
],
"healthCheck": {
"command": [
"CMD-SHELL",
"curl -s http://localhost:9901/server_info | grep state | grep -q LIVE"
],
"startPeriod": 10,
"interval": 5,
"timeout": 2,
"retries": 3
},
"user": "1337"
}
],
"requiresCompatibilities" : [ "EC2" ],
"taskRoleArn" : "arn:aws:iam::123456789012:role/ecsTaskRole",
"executionRoleArn" : "arn:aws:iam::123456789012:role/ecsTaskExecutionRole",
"networkMode": "awsvpc"
}
```
**Example JSON para definição de tarefas do Amazon ECS com AWS X-Ray - tipo de execução EC2**
```
{
"family": "taskB",
"memory": "256",
"cpu" : "1024",
"proxyConfiguration": {
"type": "APPMESH",
"containerName": "envoy",
"properties": [
{
"name": "IgnoredUID",
"value": "1337"
},
{
"name": "ProxyIngressPort",
"value": "15000"
},
{
"name": "ProxyEgressPort",
"value": "15001"
},
{
"name": "AppPorts",
"value": "9080"
},
{
"name": "EgressIgnoredIPs",
"value": "169.254.170.2,169.254.169.254"
},
{
"name": "EgressIgnoredPorts",
"value": "22"
}
]
},
"containerDefinitions": [
{
"name": "appName",
"image": "appImage",
"portMappings": [
{
"containerPort": 9080,
"hostPort": 9080,
"protocol": "tcp"
}
],
"essential": true,
"dependsOn": [
{
"containerName": "envoy",
"condition": "HEALTHY"
}
]
},
{
"name": "envoy",
"image": "840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod",
"essential": true,
"environment": [
{
"name": "APPMESH_VIRTUAL_NODE_NAME",
"value": "mesh/apps/virtualNode/serviceB"
},
{
"name": "ENABLE_ENVOY_XRAY_TRACING",
"value": "1"
}
],
"healthCheck": {
"command": [
"CMD-SHELL",
"curl -s http://localhost:9901/server_info | grep state | grep -q LIVE"
],
"startPeriod": 10,
"interval": 5,
"timeout": 2,
"retries": 3
},
"user": "1337"
},
{
"name": "xray-daemon",
"image": "amazon/aws-xray-daemon",
"user": "1337",
"essential": true,
"cpu": 32,
"memoryReservation": 256,
"portMappings": [
{
"containerPort": 2000,
"protocol": "udp"
}
]
}
],
"requiresCompatibilities" : [ "EC2" ],
"taskRoleArn" : "arn:aws:iam::123456789012:role/ecsTaskRole",
"executionRoleArn" : "arn:aws:iam::123456789012:role/ecsTaskExecutionRole",
"networkMode": "awsvpc"
}
```
## Tópicos avançados
### Implantações canário usando o App Mesh
As implantações e lançamentos canário ajudam você a alternar o tráfego entre uma versão antiga de um aplicativo e uma versão recém-implantada. Ele também monitora a integridade da versão recém-implantada. Se houver algum problema com a nova versão, a implantação canário poderá redirecionar automaticamente o tráfego para a versão antiga. As implantações canário oferecem a capacidade de alternar o tráfego entre as versões do aplicativo com mais controle.
Para mais informações sobre como implementar implantações canário para o Amazon ECS usando o App Mesh, consulte [Criar um pipeline com implantações canário para o Amazon ECS usando o App Mesh](https://aws.amazon.com/blogs/containers/create-a-pipeline-with-canary-deployments-for-amazon-ecs-using-aws-app-mesh/)
**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).
# Introdução ao AWS App Mesh Kubernetes
**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)
Ao se integrar AWS App Mesh ao Kubernetes usando o controlador App Mesh para Kubernetes, você gerencia recursos do App Mesh, como malhas, serviços virtuais, nós virtuais, roteadores virtuais e rotas por meio do Kubernetes. Também é possível adicionar automaticamente imagens de contêiner do arquivo associado do App Mesh às especificações do pod do Kubernetes. Este tutorial orienta a instalação do controlador do App Mesh para Kubernetes de forma a permitir essa integração.
O controlador é acompanhado pela implantação das seguintes definições de recursos personalizados do Kubernetes: `meshes`, `virtual services`, `virtual nodes` e `virtual routers`. O controlador observa a criação, a modificação e a exclusão dos recursos personalizados e faz alterações nos recursos [Malhas de serviço](meshes.md), [Serviços virtuais](virtual_services.md), [Nós virtuais](virtual_nodes.md), [Gateways virtuais](virtual_gateways.md), [Rotas de gateway](gateway-routes.md) e [Roteadores virtuais](virtual_routers.md) (incluindo [Rotas](routes.md)) correspondentes do App Mesh por meio da API do App Mesh. Para saber mais ou contribuir com o controlador, consulte o [GitHubprojeto](https://github.com/aws/aws-app-mesh-controller-for-k8s).
O controlador também instala um webhook que injeta os seguintes contêineres em pods do Kubernetes etiquetados com um nome que você especificar.
+ **Proxy do App Mesh Envoy**: o Envoy usa a configuração definida no ambiente de gerenciamento do App Mesh para determinar para onde enviar o tráfego do seu aplicativo.
+ **Gerenciador de rotas de proxy do App Mesh**: atualiza as regras `iptables` em um namespace de rede do pod que roteia o tráfego de entrada e saída pelo Envoy. Esse contêiner é executado como um contêiner de init do Kubernetes dentro do pod.
## Pré-requisitos
+ Uma compreensão existente dos conceitos do App Mesh. Para obter mais informações, consulte [O que é AWS App Mesh?](what-is-app-mesh.md).
+ Uma compreensão existente dos conceitos de Kubernetes. Para obter mais informações, consulte [O que é o Kubernetes](https://kubernetes.io/docs/concepts/overview/what-is-kubernetes/) na documentação do Kubernetes.
+ Um cluster do Kubernetes existente. Se você não tiver um cluster existente, consulte [Conceitos básicos do Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/getting-started.html) no *Guia do usuário do Amazon EKS*. Se você estiver executando seu próprio cluster Kubernetes no Amazon EC2, certifique-se de que o Docker esteja autenticado no repositório Amazon ECR em que a imagem do Envoy está. Para obter mais informações, consulte [Imagem do Envoy](https://docs.aws.amazon.com/app-mesh/latest/userguide/envoy.html), [Autenticação do registro](https://docs.aws.amazon.com/AmazonECR/latest/userguide/Registries.html#registry_auth) no Guia do usuário do Amazon Elastic Container Registry e [Como extrair uma imagem de um registro privado](https://kubernetes.io/docs/tasks/configure-pod-container/pull-image-private-registry/) na documentação do Kubernetes.
+ 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. Para os procedimentos nesse tópico, espera-se que os serviços existentes sejam nomeados `serviceA`, `serviceB` e `serviceBv2`; e que todos os serviços sejam detectáveis por meio de um namespace chamado `apps.local`.
É 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.
+ A AWS CLI versão 1.18.116 ou posterior ou 2.0.38 ou posterior instalada. Para instalar ou atualizar o AWS CLI, consulte [Instalando AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) o.
+ Um cliente do `kubectl` que está configurado para se comunicar com o cluster do Kubernetes. Se você estiver usando o Amazon Elastic Kubernetes Service, use as instruções para instalar `[kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html)` e configurar um arquivo `[kubeconfig](https://docs.aws.amazon.com/eks/latest/userguide/create-kubeconfig.html)`.
+ Ter o Helm versão 3.0 ou posterior instalado. Se você não tiver o Helm instalado, consulte [Como usar o Helm com o Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/helm.html) no *Guia do usuário do Amazon EKS*.
+ Atualmente, o Amazon EKS só oferece suporte `IPv4_ONLY` e `IPv6_ONLY` somente às preferências de IP, porque o Amazon EKS atualmente só oferece suporte a pods capazes de servir somente tráfego `IPv4` ou somente tráfego `IPv6`.
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: Instalar os componentes de integração
Instale os componentes de integração uma vez em cada cluster que hospeda os pods a serem usados com o App Mesh.
**Como instalar os componentes de integração**
1. As etapas restantes deste procedimento exigem um cluster sem uma versão de pré-lançamento do controlador instalada. Se você instalou uma versão de pré-lançamento ou não tem certeza se você a tem, baixe e execute um script para verificar se uma versão de pré-lançamento está instalada no seu cluster.
```
curl -o pre_upgrade_check.sh https://raw.githubusercontent.com/aws/eks-charts/master/stable/appmesh-controller/upgrade/pre_upgrade_check.sh
sh ./pre_upgrade_check.sh
```
Se o script retornar `Your cluster is ready for upgrade. Please proceed to the installation instructions`, você poderá avançar para a próxima etapa. Se for diferente, você precisará concluir as etapas de atualização antes de continuar. Para obter mais informações sobre como atualizar uma versão de pré-lançamento, consulte [Atualizar](https://github.com/aws/eks-charts/blob/master/stable/appmesh-controller/README.md#upgrade) em. GitHub
1. Adicione o repositório `eks-charts` ao Helm.
```
helm repo add eks https://aws.github.io/eks-charts
```
1. Instale as definições de recursos personalizados (CRD) do aplicativo Mesh Kubernetes.
```
kubectl apply -k "https://github.com/aws/eks-charts/stable/appmesh-controller/crds?ref=master"
```
1. Crie um namespace do Kubernetes para o controlador.
```
kubectl create ns appmesh-system
```
1. Defina as seguintes variáveis para uso nas etapas mais adiante. Substitua `cluster-name` e `Region-code` pelos valores do cluster existente.
```
export CLUSTER_NAME=cluster-name
export AWS_REGION=Region-code
```
1. (Opcional) Se você deseja executar o controlador no Fargate, é necessário criar um perfil do Fargate. Se você não tiver o `eksctl` instalado, consulte [Como instalar ou atualizar `eksctl`](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html#installing-eksctl) no *Guia do usuário do Amazon EKS*. Se preferir criar o perfil usando o console, consulte [Como criar um perfil do Fargate](https://docs.aws.amazon.com/eks/latest/userguide/fargate-profile.html#create-fargate-profile) no *Guia do usuário do Amazon EKS*.
```
eksctl create fargateprofile --cluster $CLUSTER_NAME --name appmesh-system --namespace appmesh-system
```
1. Crie um provedor de identidade OpenID Connect (OIDC) para o cluster. Se você não tiver o `eksctl` instalado, poderá instalá-lo com as instruções em [Como instalar ou atualizar `eksctl`](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html#installing-eksctl) no *Guia de usuário do Amazon EKS*. Se você preferir criar o provedor usando o console, consulte [Como habilitar perfis do IAM para contas de serviço no cluster](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html) no *Guia do usuário do Amazon EKS*.
```
eksctl utils associate-iam-oidc-provider \
--region=$AWS_REGION \
--cluster $CLUSTER_NAME \
--approve
```
1. Crie uma função do IAM, [https://console.aws.amazon.com/iam/home?#policies/arn:aws:iam::aws:policy/AWSAppMeshFullAccess$jsonEditor](https://console.aws.amazon.com/iam/home?#policies/arn:aws:iam::aws:policy/AWSAppMeshFullAccess$jsonEditor)anexe as políticas [https://console.aws.amazon.com/iam/home?#policies/arn:aws:iam::aws:policy/AWSCloudMapFullAccess$jsonEditor](https://console.aws.amazon.com/iam/home?#policies/arn:aws:iam::aws:policy/AWSCloudMapFullAccess$jsonEditor) AWS gerenciadas a ela e vincule-a à conta de serviço do `appmesh-controller` Kubernetes. A função permite que o controlador adicione, remova e altere os recursos do App Mesh.
**nota**
O comando cria uma função AWS do IAM com um nome gerado automaticamente. Não é possível especificar o nome do perfil do IAM criado.
```
eksctl create iamserviceaccount \
--cluster $CLUSTER_NAME \
--namespace appmesh-system \
--name appmesh-controller \
--attach-policy-arn arn:aws:iam::aws:policy/AWSCloudMapFullAccess,arn:aws:iam::aws:policy/AWSAppMeshFullAccess \
--override-existing-serviceaccounts \
--approve
```
Se você preferir criar a conta de serviço usando o Console de gerenciamento da AWS ou AWS CLI, consulte [Criação de uma função e política do IAM para sua conta de serviço](https://docs.aws.amazon.com/eks/latest/userguide/create-service-account-iam-policy-and-role.html#create-service-account-iam-role) no *Guia do usuário do Amazon EKS*. Se você usar Console de gerenciamento da AWS ou AWS CLI para criar a conta, também precisará mapear a função para uma conta de serviço do Kubernetes. Para obter mais informações, consulte [Como especificar um perfil do IAM para sua conta de serviço](https://docs.aws.amazon.com/eks/latest/userguide/specify-service-account-role.html) no *Guia do usuário do Amazon EKS*.
1.
**Implante o controlador do App Mesh. Para obter uma lista de todas as opções de configuração, consulte [Configuração ativada](https://github.com/aws/eks-charts/blob/master/stable/appmesh-controller/README.md#configuration) GitHub.**
1. Para implantar o controlador do App Mesh em um cluster privado, você precisa primeiro habilitar o App Mesh e os endpoints da Amazon VPC de descoberta de serviços na sub-rede privada vinculada. Você também precisa definir o `accountId`.
```
--set accountId=$AWS_ACCOUNT_ID
```
Para habilitar o rastreamento do X-Ray em um cluster privado, habilite os endpoints da Amazon VPC do X-Ray e do Amazon ECR. O controlador usa `public.ecr.aws/xray/aws-xray-daemon:latest` por padrão, portanto extraia essa imagem para o local e [envie-a para o seu repositório pessoal do ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/docker-push-ecr-image.html).
**nota**
No momento, os [endpoints da Amazon VPC](https://docs.aws.amazon.com/AmazonECR/latest/userguide/vpc-endpoints.html) não oferecem suporte aos repositórios públicos do Amazon ECR.
O exemplo a seguir mostra a implantação do controlador com configurações do X-Ray.
```
helm upgrade -i appmesh-controller eks/appmesh-controller \
--namespace appmesh-system \
--set region=$AWS_REGION \
--set serviceAccount.create=false \
--set serviceAccount.name=appmesh-controller \
--set accountId=$AWS_ACCOUNT_ID \
--set log.level=debug \
--set tracing.enabled=true \
--set tracing.provider=x-ray \
--set xray.image.repository=your-account-id.dkr.ecr.your-region.amazonaws.com/your-repository \
--set xray.image.tag=your-xray-daemon-image-tag
```
Verifique se o daemon do X-Ray foi injetado com sucesso ao vincular a implantação do aplicativo ao seu nó virtual ou gateway.
Para obter mais informações, consulte [Clusters privados](https://docs.aws.amazon.com/eks/latest/userguide/private-clusters.html) no *Guia do usuário do Amazon EKS*.
1. Implante o controlador do App Mesh para outros clusters. Para obter uma lista de todas as opções de configuração, consulte [Configuração ativada](https://github.com/aws/eks-charts/blob/master/stable/appmesh-controller/README.md#configuration) GitHub.
```
helm upgrade -i appmesh-controller eks/appmesh-controller \
--namespace appmesh-system \
--set region=$AWS_REGION \
--set serviceAccount.create=false \
--set serviceAccount.name=appmesh-controller
```
**nota**
Se sua família de cluster do Amazon EKS for `IPv6`, defina o nome do cluster ao implantar o controlador do App Mesh adicionando a seguinte opção ao comando `--set clusterName=$CLUSTER_NAME` anterior.
**Importante**
Se seu cluster estiver em `me-south-1`, `ap-east-1`, `ap-southeast-3`, `eu-south-1`, `il-central-1` ou `af-south-1`, você precisará adicionar as seguintes opções ao comando anterior:
*Region-code*Substitua *account-id* e por um dos conjuntos de valores apropriados.
```
--set image.repository=account-id.dkr.ecr.Region-code.amazonaws.com/amazon/appmesh-controller
```
772975370895.dkr. ecr.me-south-1.amazonaws.com /:v1.34.13.0-prod aws-appmesh-envoy
856666278305.dkr. ecr.ap-east-1.amazonaws.com /:v1.34.13.0-prod aws-appmesh-envoy
909464085924.dkr. ecr.ap-southeast-3.amazonaws.com /:v1.34.13.0-prod aws-appmesh-envoy
422531588944.dkr. ecr.eu-south-1.amazonaws.com /:v1.34.13.0-prod aws-appmesh-envoy
564877687649.dkr. ecr.il-central-1.amazonaws.com /:v1.34.13.0-prod aws-appmesh-envoy
924023996002.dkr. ecr.af-south-1.amazonaws.com /:v1.34.13.0-prod aws-appmesh-envoy
A imagem mais antiga URIs pode ser encontrada no [log de alterações](https://github.com/aws/aws-app-mesh-controller-for-k8s/releases) GitHub. As AWS contas nas quais as imagens estão presentes mudaram de versão`v1.5.0`. As versões mais antigas das imagens são hospedadas em contas da AWS encontradas nos registros de imagens de contêineres da Amazon no [Amazon Elastic Kubernetes Service](https://docs.aws.amazon.com/eks/latest/userguide/add-ons-images.html).
```
--set sidecar.image.repository=account-id.dkr.ecr.Region-code.amazonaws.com/aws-appmesh-envoy
```
772975370895.dkr.ecr.me-south-1.amazonaws. com/amazon/appmesh-controlador: v1.13.1
856666278305.dkr.ecr.ap-east-1.amazonaws. com/amazon/appmesh-controlador: v1.13.1
909464085924.dkr.ecr.ap-southeast-3.amazonaws. com/amazon/appmesh-controlador: v1.13.1
422531588944.dkr.ecr.eu-south-1.amazonaws. com/amazon/appmesh-controlador: v1.13.1
564877687649.dkr.ecr.il-central-1.amazonaws. com/amazon/appmesh-controlador: v1.13.1
924023996002.dkr.ecr.af-south-1.amazonaws. com/amazon/appmesh-controlador: v1.13.1
```
--set sidecar.image.repository=account-id.dkr.ecr.Region-code.amazonaws.com/aws-appmesh-envoy
```
772975370895.dkr. ecr.me-south-1.amazonaws.com/-manager:v7-prod aws-appmesh-proxy-route
856666278305.dkr. ecr.ap-east-1.amazonaws.com/-manager:v7-prod aws-appmesh-proxy-route
909464085924.dkr. ecr.ap-southeast-3.amazonaws.com/-manager:v7-prod aws-appmesh-proxy-route
422531588944.dkr. ecr.eu-south-1.amazonaws.com/-manager:v7-prod aws-appmesh-proxy-route
564877687649.dkr. ecr.il-central-1.amazonaws.com/-manager:v7-prod aws-appmesh-proxy-route
924023996002.dkr. ecr.af-south-1.amazonaws.com/-manager:v7-prod aws-appmesh-proxy-route
**Importante**
Somente a versão v1.9.0.0-prod ou posterior é compatível para uso com o App Mesh.
1. Confirme se a versão do controlador é `v1.4.0` ou posterior. Você pode revisar o [registro de alterações](https://github.com/aws/aws-app-mesh-controller-for-k8s/releases) GitHub.
```
kubectl get deployment appmesh-controller \
-n appmesh-system \
-o json | jq -r ".spec.template.spec.containers[].image" | cut -f2 -d ':'
```
**nota**
Se visualizar o log para o contêiner em execução, você poderá ver uma linha que inclui o seguinte texto, que pode ser ignorado com segurança.
```
Neither -kubeconfig nor -master was specified. Using the inClusterConfig. This might not work.
```
## Etapa 2: Como implantar recursos do App Mesh
Quando você implanta um aplicativo no Kubernetes, você também cria os recursos personalizados do Kubernetes para que o controlador possa criar os recursos do App Mesh correspondentes. O procedimento a seguir ajuda a implantar recursos do App Mesh com alguns atributos deles. Você pode encontrar exemplos de manifestos para implantar outros recursos de recursos do App Mesh nas `v1beta2` subpastas de muitas das pastas de recursos listadas nas orientações do [App Mesh](https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs) em. GitHub
**Importante**
Depois que o controlador criar um recurso do App Mesh, recomendamos fazer apenas alterações ou excluir o recurso do App Mesh usando o controlador. Se você fizer alterações ou excluir o recurso usando o App Mesh, o controlador não alterará nem recriará o recurso alterado ou excluído do App Mesh por dez horas, por padrão. Você pode configurar essa duração para ser menor. Para obter mais informações, consulte [Configuração ativada](https://github.com/aws/eks-charts/blob/master/stable/appmesh-controller/README.md#configuration) GitHub.
**Como implantar recursos do App Mesh**
1. Crie um namespace do Kubernetes no qual implantar recursos do App Mesh.
1. Salve o seguinte conteúdo no seu computador, em um arquivo chamado `namespace.yaml`:
```
apiVersion: v1
kind: Namespace
metadata:
name: my-apps
labels:
mesh: my-mesh
appmesh.k8s.aws/sidecarInjectorWebhook: enabled
```
1. Crie o novo namespace.
```
kubectl apply -f namespace.yaml
```
1. Crie uma malha de serviços do App Mesh.
1. Salve o seguinte conteúdo no seu computador, em um arquivo chamado `mesh.yaml`: O arquivo é usado para criar um recurso de malha chamado `my-mesh`. Uma malha de serviços é um limite lógico para o tráfego de rede entre os serviços que residem nela.
```
apiVersion: appmesh.k8s.aws/v1beta2
kind: Mesh
metadata:
name: my-mesh
spec:
namespaceSelector:
matchLabels:
mesh: my-mesh
```
1. Crie a malha.
```
kubectl apply -f mesh.yaml
```
1. Veja os detalhes do recurso de malha do Kubernetes que foi criado.
```
kubectl describe mesh my-mesh
```
Output
```
Name: my-mesh
Namespace:
Labels:
Annotations: kubectl.kubernetes.io/last-applied-configuration:
{"apiVersion":"appmesh.k8s.aws/v1beta2","kind":"Mesh","metadata":{"annotations":{},"name":"my-mesh"},"spec":{"namespaceSelector":{"matchLa...
API Version: appmesh.k8s.aws/v1beta2
Kind: Mesh
Metadata:
Creation Timestamp: 2020-06-17T14:51:37Z
Finalizers:
finalizers.appmesh.k8s.aws/mesh-members
finalizers.appmesh.k8s.aws/aws-appmesh-resources
Generation: 1
Resource Version: 6295
Self Link: /apis/appmesh.k8s.aws/v1beta2/meshes/my-mesh
UID: 111a11b1-c11d-1e1f-gh1i-j11k1l111m711
Spec:
Aws Name: my-mesh
Namespace Selector:
Match Labels:
Mesh: my-mesh
Status:
Conditions:
Last Transition Time: 2020-06-17T14:51:37Z
Status: True
Type: MeshActive
Mesh ARN: arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh
Observed Generation: 1
Events:
```
1. Veja os detalhes sobre a malha de serviços do App Mesh que o controlador criou.
```
aws appmesh describe-mesh --mesh-name my-mesh
```
Output
```
{
"mesh": {
"meshName": "my-mesh",
"metadata": {
"arn": "arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh",
"createdAt": "2020-06-17T09:51:37.920000-05:00",
"lastUpdatedAt": "2020-06-17T09:51:37.920000-05:00",
"meshOwner": "111122223333",
"resourceOwner": "111122223333",
"uid": "111a11b1-c11d-1e1f-gh1i-j11k1l111m711",
"version": 1
},
"spec": {},
"status": {
"status": "ACTIVE"
}
}
}
```
1. Crie um nó virtual do App Mesh. Um nó virtual atua como um ponteiro lógico para uma implantação do Kubernetes.
1. Salve o seguinte conteúdo no seu computador, em um arquivo chamado `virtual-node.yaml`: O arquivo será usado para criar um nó virtual do App Mesh chamado `my-service-a` no namespace *`my-apps`*. O nó virtual representa um serviço do Kubernetes criado em uma etapa posterior. O valor de `hostname` é o nome de hospedagem DNS totalmente qualificado do serviço real que este nó virtual representa.
```
apiVersion: appmesh.k8s.aws/v1beta2
kind: VirtualNode
metadata:
name: my-service-a
namespace: my-apps
spec:
podSelector:
matchLabels:
app: my-app-1
listeners:
- portMapping:
port: 80
protocol: http
serviceDiscovery:
dns:
hostname: my-service-a.my-apps.svc.cluster.local
```
Os nós virtuais têm recursos, como end-to-end criptografia e verificações de integridade, que não são abordados neste tutorial. Para obter mais informações, consulte [Nós virtuais](virtual_nodes.md). Para ver todas as configurações disponíveis para um nó virtual que é possível definir na especificação anterior, execute o comando a seguir.
```
aws appmesh create-virtual-node --generate-cli-skeleton yaml-input
```
1. Implante o nó virtual.
```
kubectl apply -f virtual-node.yaml
```
1. Veja os detalhes do recurso de nó virtual do Kubernetes que foi criado.
```
kubectl describe virtualnode my-service-a -n my-apps
```
Output
```
Name: my-service-a
Namespace: my-apps
Labels:
Annotations: kubectl.kubernetes.io/last-applied-configuration:
{"apiVersion":"appmesh.k8s.aws/v1beta2","kind":"VirtualNode","metadata":{"annotations":{},"name":"my-service-a","namespace":"my-apps"},"s...
API Version: appmesh.k8s.aws/v1beta2
Kind: VirtualNode
Metadata:
Creation Timestamp: 2020-06-17T14:57:29Z
Finalizers:
finalizers.appmesh.k8s.aws/aws-appmesh-resources
Generation: 2
Resource Version: 22545
Self Link: /apis/appmesh.k8s.aws/v1beta2/namespaces/my-apps/virtualnodes/my-service-a
UID: 111a11b1-c11d-1e1f-gh1i-j11k1l111m711
Spec:
Aws Name: my-service-a_my-apps
Listeners:
Port Mapping:
Port: 80
Protocol: http
Mesh Ref:
Name: my-mesh
UID: 111a11b1-c11d-1e1f-gh1i-j11k1l111m711
Pod Selector:
Match Labels:
App: nginx
Service Discovery:
Dns:
Hostname: my-service-a.my-apps.svc.cluster.local
Status:
Conditions:
Last Transition Time: 2020-06-17T14:57:29Z
Status: True
Type: VirtualNodeActive
Observed Generation: 2
Virtual Node ARN: arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualNode/my-service-a_my-apps
Events:
```
1. Veja os detalhes do nó virtual que o controlador criou no App Mesh.
**nota**
Embora o nome do nó virtual criado no Kubernetes seja `my-service-a`, o nome do nó virtual criado no App Mesh é `my-service-a_my-apps`. O controlador acrescenta o nome do namespace do Kubernetes ao nome do nó virtual do App Mesh ao criar o recurso do App Mesh. O nome do namespace é adicionado porque no Kubernetes é possível criar nós virtuais com o mesmo nome em namespaces diferentes, mas no App Mesh, um nome de nó virtual deve ser exclusivo em uma malha.
```
aws appmesh describe-virtual-node --mesh-name my-mesh --virtual-node-name my-service-a_my-apps
```
Output
```
{
"virtualNode": {
"meshName": "my-mesh",
"metadata": {
"arn": "arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualNode/my-service-a_my-apps",
"createdAt": "2020-06-17T09:57:29.840000-05:00",
"lastUpdatedAt": "2020-06-17T09:57:29.840000-05:00",
"meshOwner": "111122223333",
"resourceOwner": "111122223333",
"uid": "111a11b1-c11d-1e1f-gh1i-j11k1l111m711",
"version": 1
},
"spec": {
"backends": [],
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http"
}
}
],
"serviceDiscovery": {
"dns": {
"hostname": "my-service-a.my-apps.svc.cluster.local"
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualNodeName": "my-service-a_my-apps"
}
}
```
1. Crie um roteador virtual do App Mesh. Os roteadores virtuais manipulam o tráfego de um ou mais serviços virtuais dentro da malha.
1. Salve o seguinte conteúdo no seu computador, em um arquivo chamado `virtual-router.yaml`: O arquivo é usado para criar um tráfego de roteador a roteador virtual para o nó virtual chamado `my-service-a` que foi criado na etapa anterior. O controlador cria o roteador virtual e os recursos de roteamento do App Mesh. É possível especificar muitos mais recursos para suas rotas e usar protocolos diferentes de `http`. Para obter mais informações, consulte [Roteadores virtuais](virtual_routers.md) e [Rotas](routes.md). Perceba que o nome do nó virtual referenciado é o nome do nó virtual do Kubernetes, não o nome do nó virtual do App Mesh que foi criado no App Mesh pelo controlador.
```
apiVersion: appmesh.k8s.aws/v1beta2
kind: VirtualRouter
metadata:
namespace: my-apps
name: my-service-a-virtual-router
spec:
listeners:
- portMapping:
port: 80
protocol: http
routes:
- name: my-service-a-route
httpRoute:
match:
prefix: /
action:
weightedTargets:
- virtualNodeRef:
name: my-service-a
weight: 1
```
(Opcional) Para ver todas as configurações disponíveis para roteador virtual que podem ser definidas na especificação anterior, execute o comando a seguir.
```
aws appmesh create-virtual-router --generate-cli-skeleton yaml-input
```
Para ver todas as configurações disponíveis para uma rota que podem ser definidas na especificação anterior, execute o comando a seguir.
```
aws appmesh create-route --generate-cli-skeleton yaml-input
```
1. Implante o roteador virtual.
```
kubectl apply -f virtual-router.yaml
```
1. Veja o recurso de roteador virtual do Kubernetes que foi criado.
```
kubectl describe virtualrouter my-service-a-virtual-router -n my-apps
```
Resultado abreviado
```
Name: my-service-a-virtual-router
Namespace: my-apps
Labels:
Annotations: kubectl.kubernetes.io/last-applied-configuration:
{"apiVersion":"appmesh.k8s.aws/v1beta2","kind":"VirtualRouter","metadata":{"annotations":{},"name":"my-service-a-virtual-router","namespac...
API Version: appmesh.k8s.aws/v1beta2
Kind: VirtualRouter
...
Spec:
Aws Name: my-service-a-virtual-router_my-apps
Listeners:
Port Mapping:
Port: 80
Protocol: http
Mesh Ref:
Name: my-mesh
UID: 111a11b1-c11d-1e1f-gh1i-j11k1l111m711
Routes:
Http Route:
Action:
Weighted Targets:
Virtual Node Ref:
Name: my-service-a
Weight: 1
Match:
Prefix: /
Name: my-service-a-route
Status:
Conditions:
Last Transition Time: 2020-06-17T15:14:01Z
Status: True
Type: VirtualRouterActive
Observed Generation: 1
Route AR Ns:
My - Service - A - Route: arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualRouter/my-service-a-virtual-router_my-apps/route/my-service-a-route
Virtual Router ARN: arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualRouter/my-service-a-virtual-router_my-apps
Events:
```
1. Veja o recurso de roteador virtual que o controlador criou no App Mesh. Especifique `my-service-a-virtual-router_my-apps` para `name`, porque quando o controlador criou o roteador virtual no App Mesh, ele anexou o nome do namespace do Kubernetes ao nome do roteador virtual.
```
aws appmesh describe-virtual-router --virtual-router-name my-service-a-virtual-router_my-apps --mesh-name my-mesh
```
Output
```
{
"virtualRouter": {
"meshName": "my-mesh",
"metadata": {
"arn": "arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualRouter/my-service-a-virtual-router_my-apps",
"createdAt": "2020-06-17T10:14:01.547000-05:00",
"lastUpdatedAt": "2020-06-17T10:14:01.547000-05:00",
"meshOwner": "111122223333",
"resourceOwner": "111122223333",
"uid": "111a11b1-c11d-1e1f-gh1i-j11k1l111m711",
"version": 1
},
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http"
}
}
]
},
"status": {
"status": "ACTIVE"
},
"virtualRouterName": "my-service-a-virtual-router_my-apps"
}
}
```
1. Veja o recurso de rota que o controlador criou no App Mesh. Um recurso de rota não foi criado no Kubernetes porque a rota faz parte da configuração do roteador virtual no Kubernetes. As informações da rota foram mostradas nos detalhes do recurso do Kubernetes na subetapa `c`. O controlador não acrescentou o nome do namespace do Kubernetes ao nome da rota do App Mesh ao criar a rota no App Mesh porque os nomes de rota são exclusivos de um roteador virtual.
```
aws appmesh describe-route \
--route-name my-service-a-route \
--virtual-router-name my-service-a-virtual-router_my-apps \
--mesh-name my-mesh
```
Output
```
{
"route": {
"meshName": "my-mesh",
"metadata": {
"arn": "arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualRouter/my-service-a-virtual-router_my-apps/route/my-service-a-route",
"createdAt": "2020-06-17T10:14:01.577000-05:00",
"lastUpdatedAt": "2020-06-17T10:14:01.577000-05:00",
"meshOwner": "111122223333",
"resourceOwner": "111122223333",
"uid": "111a11b1-c11d-1e1f-gh1i-j11k1l111m711",
"version": 1
},
"routeName": "my-service-a-route",
"spec": {
"httpRoute": {
"action": {
"weightedTargets": [
{
"virtualNode": "my-service-a_my-apps",
"weight": 1
}
]
},
"match": {
"prefix": "/"
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualRouterName": "my-service-a-virtual-router_my-apps"
}
}
```
1. Crie um serviço virtual do App Mesh. Um serviço virtual é uma abstração de um serviço real que é fornecido por um nó virtual direta ou indiretamente por meio de um roteador virtual. Os serviços dependentes chamam o serviço virtual pelo nome. Embora o nome não seja importante para o App Mesh, recomendamos nomear o serviço virtual com o nome de domínio totalmente qualificado do serviço real que o serviço virtual representa. Ao nomear seus serviços virtuais dessa forma, você não precisa alterar o código do aplicativo para fazer referência a um nome diferente. As solicitações são roteadas para o nó virtual ou o roteador virtual especificado como o provedor para o serviço virtual.
1. Salve o seguinte conteúdo no seu computador, em um arquivo chamado `virtual-service.yaml`: O arquivo é usado para criar um serviço virtual que usa um provedor de roteador virtual para direcionar o tráfego para o nó virtual chamado `my-service-a` criado em uma etapa anterior. O valor para `awsName` em `spec` é o nome de domínio totalmente qualificado (FQDN) do serviço do Kubernetes real extraído por este serviço virtual. O serviço Kubernetes é criado no [Etapa 3: Criar ou atualizar serviços](#create-update-services). Para obter mais informações, consulte [Serviços virtuais](virtual_services.md).
```
apiVersion: appmesh.k8s.aws/v1beta2
kind: VirtualService
metadata:
name: my-service-a
namespace: my-apps
spec:
awsName: my-service-a.my-apps.svc.cluster.local
provider:
virtualRouter:
virtualRouterRef:
name: my-service-a-virtual-router
```
Para ver todas as configurações disponíveis para um serviço virtual que é possível definir na especificação anterior, execute o comando a seguir.
```
aws appmesh create-virtual-service --generate-cli-skeleton yaml-input
```
1. Crie o serviço virtual.
```
kubectl apply -f virtual-service.yaml
```
1. Veja os detalhes do recurso de serviço virtual do Kubernetes que foi criado.
```
kubectl describe virtualservice my-service-a -n my-apps
```
Output
```
Name: my-service-a
Namespace: my-apps
Labels:
Annotations: kubectl.kubernetes.io/last-applied-configuration:
{"apiVersion":"appmesh.k8s.aws/v1beta2","kind":"VirtualService","metadata":{"annotations":{},"name":"my-service-a","namespace":"my-apps"}...
API Version: appmesh.k8s.aws/v1beta2
Kind: VirtualService
Metadata:
Creation Timestamp: 2020-06-17T15:48:40Z
Finalizers:
finalizers.appmesh.k8s.aws/aws-appmesh-resources
Generation: 1
Resource Version: 13598
Self Link: /apis/appmesh.k8s.aws/v1beta2/namespaces/my-apps/virtualservices/my-service-a
UID: 111a11b1-c11d-1e1f-gh1i-j11k1l111m711
Spec:
Aws Name: my-service-a.my-apps.svc.cluster.local
Mesh Ref:
Name: my-mesh
UID: 111a11b1-c11d-1e1f-gh1i-j11k1l111m711
Provider:
Virtual Router:
Virtual Router Ref:
Name: my-service-a-virtual-router
Status:
Conditions:
Last Transition Time: 2020-06-17T15:48:40Z
Status: True
Type: VirtualServiceActive
Observed Generation: 1
Virtual Service ARN: arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualService/my-service-a.my-apps.svc.cluster.local
Events:
```
1. Veja os detalhes do recurso de serviço virtual que o controlador criou no App Mesh. O controlador do Kubernetes não acrescentou o nome do namespace do Kubernetes ao nome do serviço virtual do App Mesh ao criar o serviço virtual no App Mesh porque o nome do serviço virtual é um FQDN exclusivo.
```
aws appmesh describe-virtual-service --virtual-service-name my-service-a.my-apps.svc.cluster.local --mesh-name my-mesh
```
Output
```
{
"virtualService": {
"meshName": "my-mesh",
"metadata": {
"arn": "arn:aws:appmesh:us-west-2:111122223333:mesh/my-mesh/virtualService/my-service-a.my-apps.svc.cluster.local",
"createdAt": "2020-06-17T10:48:40.182000-05:00",
"lastUpdatedAt": "2020-06-17T10:48:40.182000-05:00",
"meshOwner": "111122223333",
"resourceOwner": "111122223333",
"uid": "111a11b1-c11d-1e1f-gh1i-j11k1l111m711",
"version": 1
},
"spec": {
"provider": {
"virtualRouter": {
"virtualRouterName": "my-service-a-virtual-router_my-apps"
}
}
},
"status": {
"status": "ACTIVE"
},
"virtualServiceName": "my-service-a.my-apps.svc.cluster.local"
}
}
```
Embora não seja abordado neste tutorial, o controlador também pode implantar [Gateways virtuais](virtual_gateways.md) e [Rotas de gateway](gateway-routes.md) do App Mesh. Para ver um passo a passo da implantação desses recursos com o controlador, consulte [Configurando o gateway de entrada](https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs/howto-k8s-ingress-gateway) ou um [exemplo de manifesto](https://github.com/aws/aws-app-mesh-examples/blob/main/walkthroughs/howto-k8s-ingress-gateway/v1beta2/manifest.yaml.template) que inclui os recursos em. GitHub
## Etapa 3: Criar ou atualizar serviços
Todos os pods a serem usados com o App Mesh devem ter os contêineres associados do App Mesh adicionados a eles. O injetor adiciona automaticamente os contêineres associados a qualquer pod implantado com uma etiqueta especificada.
1. Habilite a autorização de proxy. Recomendamos que você habilite cada implantação do Kubernetes para transmitir somente a configuração de seu próprio nó virtual do App Mesh.
1. Salve o seguinte conteúdo no seu computador, em um arquivo chamado `proxy-auth.json`: Certifique-se de *alternate-colored values* substituí-lo pelo seu.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "appmesh:StreamAggregatedResources",
"Resource": [
"arn:aws:appmesh:us-east-1:111122223333:mesh/my-mesh/virtualNode/my-service-a_my-apps"
]
}
]
}
```
------
1. Crie a política .
```
aws iam create-policy --policy-name my-policy --policy-document file://proxy-auth.json
```
1. Crie um perfil do IAM, associe a ela a política criada na etapa anterior, crie uma conta de serviço do Kubernetes e vincule a política à conta de serviço do Kubernetes. A função permite que o controlador adicione, remova e altere os recursos do App Mesh.
```
eksctl create iamserviceaccount \
--cluster $CLUSTER_NAME \
--namespace my-apps \
--name my-service-a \
--attach-policy-arn arn:aws:iam::111122223333:policy/my-policy \
--override-existing-serviceaccounts \
--approve
```
Se você preferir criar a conta de serviço usando o Console de gerenciamento da AWS ou AWS CLI, consulte [Criação de uma função e política do IAM para sua conta de serviço](https://docs.aws.amazon.com/eks/latest/userguide/create-service-account-iam-policy-and-role.html#create-service-account-iam-role) no *Guia do usuário do Amazon EKS*. Se você usar Console de gerenciamento da AWS ou AWS CLI para criar a conta, também precisará mapear a função para uma conta de serviço do Kubernetes. Para obter mais informações, consulte [Como especificar um perfil do IAM para sua conta de serviço](https://docs.aws.amazon.com/eks/latest/userguide/specify-service-account-role.html) no *Guia do usuário do Amazon EKS*.
1. (Opcional) Se você deseja fazer sua implantação em pods do Fargate, será necessário criar um perfil do Fargate. Se você não tiver o `eksctl` instalado, poderá instalá-lo com as instruções em [Como instalar ou atualizar `eksctl`](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html#installing-eksctl) no *Guia de usuário do Amazon EKS*. Se preferir criar o perfil usando o console, consulte [Como criar um perfil do Fargate](https://docs.aws.amazon.com/eks/latest/userguide/fargate-profile.html#create-fargate-profile) no *Guia do usuário do Amazon EKS*.
```
eksctl create fargateprofile --cluster my-cluster --region Region-code --name my-service-a --namespace my-apps
```
1. Crie um serviço e uma implantação do Kubernetes. Se você tem uma implantação existente que deseja usar com o App Mesh, precisará implantar um nó virtual, como fez na subetapa `3` de [Etapa 2: Como implantar recursos do App Mesh](#configure-app-mesh). Atualize sua implantação para garantir que o rótulo corresponda àquele definido no nó virtual, para que os contêineres auxiliares sejam automaticamente adicionados aos pods e os pods sejam reimplantados.
1. Salve o seguinte conteúdo no seu computador, em um arquivo chamado `example-service.yaml`: Se você alterar o nome do namespace e estiver usando pods do Fargate, certifique-se de que nome do namespace corresponda ao àquele definido no seu perfil do Fargate.
```
apiVersion: v1
kind: Service
metadata:
name: my-service-a
namespace: my-apps
labels:
app: my-app-1
spec:
selector:
app: my-app-1
ports:
- protocol: TCP
port: 80
targetPort: 80
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: my-service-a
namespace: my-apps
labels:
app: my-app-1
spec:
replicas: 3
selector:
matchLabels:
app: my-app-1
template:
metadata:
labels:
app: my-app-1
spec:
serviceAccountName: my-service-a
containers:
- name: nginx
image: nginx:1.19.0
ports:
- containerPort: 80
```
**Importante**
O valor para `app` `matchLabels` `selector` na especificação deve corresponder àquele especificado na criação do nó virtual na subetapa `3` em [Etapa 2: Como implantar recursos do App Mesh](#configure-app-mesh), ou os contêineres associados não serão injetados no pod. No exemplo anterior, o valor para o rótulo é `my-app-1`. Se você implantar um gateway virtual, em vez de um nó virtual, o `Deployment` manifesto deverá incluir somente o contêiner Envoy. Para mais informações sobre a imagem a ser usada, consulte [Imagem do Envoy](envoy.md). Para ver um exemplo de manifestação, consulte o [exemplo de implantação](https://github.com/aws/aws-app-mesh-examples/blob/main/walkthroughs/howto-k8s-ingress-gateway/v1beta2/manifest.yaml.template#L585) em. GitHub
1. Implante o serviço.
```
kubectl apply -f example-service.yaml
```
1. Visualize o serviço e a implantação.
```
kubectl -n my-apps get pods
```
Output
```
NAME READY STATUS RESTARTS AGE
my-service-a-54776556f6-2cxd9 2/2 Running 0 10s
my-service-a-54776556f6-w26kf 2/2 Running 0 18s
my-service-a-54776556f6-zw5kt 2/2 Running 0 26s
```
1. Visualize os detalhes de um dos pods que foi implantado.
```
kubectl -n my-apps describe pod my-service-a-54776556f6-2cxd9
```
Resultado abreviado
```
Name: my-service-a-54776556f6-2cxd9
Namespace: my-app-1
Priority: 0
Node: ip-192-168-44-157.us-west-2.compute.internal/192.168.44.157
Start Time: Wed, 17 Jun 2020 11:08:59 -0500
Labels: app=nginx
pod-template-hash=54776556f6
Annotations: kubernetes.io/psp: eks.privileged
Status: Running
IP: 192.168.57.134
IPs:
IP: 192.168.57.134
Controlled By: ReplicaSet/my-service-a-54776556f6
Init Containers:
proxyinit:
Container ID: docker://e0c4810d584c21ae0cb6e40f6119d2508f029094d0e01c9411c6cf2a32d77a59
Image: 111345817488.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-proxy-route-manager:v2
Image ID: docker-pullable://111345817488.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-proxy-route-manager
Port:
Host Port:
State: Terminated
Reason: Completed
Exit Code: 0
Started: Fri, 26 Jun 2020 08:36:22 -0500
Finished: Fri, 26 Jun 2020 08:36:22 -0500
Ready: True
Restart Count: 0
Requests:
cpu: 10m
memory: 32Mi
Environment:
APPMESH_START_ENABLED: 1
APPMESH_IGNORE_UID: 1337
APPMESH_ENVOY_INGRESS_PORT: 15000
APPMESH_ENVOY_EGRESS_PORT: 15001
APPMESH_APP_PORTS: 80
APPMESH_EGRESS_IGNORED_IP: 169.254.169.254
APPMESH_EGRESS_IGNORED_PORTS: 22
AWS_ROLE_ARN: arn:aws:iam::111122223333:role/eksctl-app-mesh-addon-iamserviceaccount-my-a-Role1-NMNCVWB6PL0N
AWS_WEB_IDENTITY_TOKEN_FILE: /var/run/secrets/eks.amazonaws.com/serviceaccount/token
...
Containers:
nginx:
Container ID: docker://be6359dc6ecd3f18a1c87df7b57c2093e1f9db17d5b3a77f22585ce3bcab137a
Image: nginx:1.19.0
Image ID: docker-pullable://nginx
Port: 80/TCP
Host Port: 0/TCP
State: Running
Started: Fri, 26 Jun 2020 08:36:28 -0500
Ready: True
Restart Count: 0
Environment:
AWS_ROLE_ARN: arn:aws:iam::111122223333:role/eksctl-app-mesh-addon-iamserviceaccount-my-a-Role1-NMNCVWB6PL0N
AWS_WEB_IDENTITY_TOKEN_FILE: /var/run/secrets/eks.amazonaws.com/serviceaccount/token
...
envoy:
Container ID: docker://905b55cbf33ef3b3debc51cb448401d24e2e7c2dbfc6a9754a2c49dd55a216b6
Image: 840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.12.4.0-prod
Image ID: docker-pullable://840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy
Port: 9901/TCP
Host Port: 0/TCP
State: Running
Started: Fri, 26 Jun 2020 08:36:36 -0500
Ready: True
Restart Count: 0
Requests:
cpu: 10m
memory: 32Mi
Environment:
APPMESH_RESOURCE_ARN: arn:aws:iam::111122223333:mesh/my-mesh/virtualNode/my-service-a_my-apps
APPMESH_PREVIEW: 0
ENVOY_LOG_LEVEL: info
AWS_REGION: us-west-2
AWS_ROLE_ARN: arn:aws:iam::111122223333:role/eksctl-app-mesh-addon-iamserviceaccount-my-a-Role1-NMNCVWB6PL0N
AWS_WEB_IDENTITY_TOKEN_FILE: /var/run/secrets/eks.amazonaws.com/serviceaccount/token
...
Events:
Type Reason Age From Message
---- ------ ---- ---- -------
Normal Pulling 30s kubelet, ip-192-168-44-157.us-west-2.compute.internal Pulling image "111345817488.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-proxy-route-manager:v2"
Normal Pulled 23s kubelet, ip-192-168-44-157.us-west-2.compute.internal Successfully pulled image "111345817488.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-proxy-route-manager:v2"
Normal Created 21s kubelet, ip-192-168-44-157.us-west-2.compute.internal Created container proxyinit
Normal Started 21s kubelet, ip-192-168-44-157.us-west-2.compute.internal Started container proxyinit
Normal Pulling 20s kubelet, ip-192-168-44-157.us-west-2.compute.internal Pulling image "nginx:1.19.0"
Normal Pulled 16s kubelet, ip-192-168-44-157.us-west-2.compute.internal Successfully pulled image "nginx:1.19.0"
Normal Created 15s kubelet, ip-192-168-44-157.us-west-2.compute.internal Created container nginx
Normal Started 15s kubelet, ip-192-168-44-157.us-west-2.compute.internal Started container nginx
Normal Pulling 15s kubelet, ip-192-168-44-157.us-west-2.compute.internal Pulling image "840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.12.4.0-prod"
Normal Pulled 8s kubelet, ip-192-168-44-157.us-west-2.compute.internal Successfully pulled image "840364872350.dkr.ecr.us-west-2.amazonaws.com/aws-appmesh-envoy:v1.12.4.0-prod"
Normal Created 7s kubelet, ip-192-168-44-157.us-west-2.compute.internal Created container envoy
Normal Started 7s kubelet, ip-192-168-44-157.us-west-2.compute.internal Started container envoy
```
No resultado anterior, é possível ver que os contêineres `proxyinit` e `envoy` foram adicionados ao pod pelo controlador. Se você implantou o serviço de exemplo no Fargate, o contêiner `envoy` foi adicionado ao pod pelo controlador, mas o contêiner `proxyinit` não foi.
1. (Opcional) Instale complementos como Prometheus, Grafana, Jaeger e AWS X-Ray Datadog. Para obter mais informações, consulte [os complementos do App Mesh](https://github.com/aws/eks-charts#app-mesh-add-ons) GitHub e a seção [Observabilidade](https://docs.aws.amazon.com/app-mesh/latest/userguide/observability.html) do Guia do usuário do App Mesh.
**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).
## Etapa 4: limpar
Remova todos os recursos de exemplo criados neste tutorial. O controlador também remove os recursos criados na malha de serviços `my-mesh` do App Mesh.
```
kubectl delete namespace my-apps
```
Se você criou um perfil do Fargate para o serviço de exemplo, remova-o.
```
eksctl delete fargateprofile --name my-service-a --cluster my-cluster --region Region-code
```
Exclua a malha.
```
kubectl delete mesh my-mesh
```
(Opcional) É possível remover os componentes de integração do Kubernetes.
```
helm delete appmesh-controller -n appmesh-system
```
(Opcional) Se você implantou os componentes de integração do Kubernetes no Fargate, exclua o perfil do Fargate.
```
eksctl delete fargateprofile --name appmesh-system --cluster my-cluster --region Region-code
```
# 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).
# Exemplos do App Mesh
**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)
Você pode encontrar end-to-end instruções passo a passo mostrando exemplos AWS App Mesh de ação e códigos para integração com vários AWS serviços no seguinte repositório:
[Exemplos do App Mesh](https://github.com/aws/aws-app-mesh-examples)