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á.
# 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}}
```