Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Primeros pasos con AWS App Mesh Kubernetes
**importante**
Aviso de fin del soporte: el 30 de septiembre de 2026, AWS dejaremos de ofrecer soporte para. AWS App Mesh Después del 30 de septiembre de 2026, ya no podrás acceder a la AWS App Mesh consola ni a AWS App Mesh los recursos. Para obtener más información, visite esta entrada del blog [Migración desde AWS App Mesh a Amazon ECS Service Connect](https://aws.amazon.com/blogs/containers/migrating-from-aws-app-mesh-to-amazon-ecs-service-connect).
Cuando te integras AWS App Mesh con Kubernetes mediante el controlador App Mesh para Kubernetes, administras los recursos de App Mesh, como mallas, servicios virtuales, nodos virtuales, enrutadores virtuales y rutas a través de Kubernetes. También puede agregar automáticamente las imágenes del contenedor sidecar de App Mesh a las especificaciones del pod de Kubernetes. Este tutorial le guiará a través de la instalación del controlador de App Mesh para Kubernetes para que esa integración sea posible.
El controlador va acompañado de la implementación de las siguientes definiciones de recursos personalizados de Kubernetes: `meshes`, `virtual services`, `virtual nodes` y `virtual routers`. El controlador supervisa la creación, modificación y eliminación de los recursos personalizados y realiza cambios en los recursos de App Mesh correspondientes: [Mallas de servicios](meshes.md) [Servicios virtuales](virtual_services.md), [Nodos virtuales](virtual_nodes.md), [Puertas de enlace virtuales](virtual_gateways.md), [Rutas de puertas de enlace](gateway-routes.md) y [Enrutadores virtuales](virtual_routers.md) (incluidas [Rutas](routes.md)) mediante la API de App Mesh. [Para obtener más información o contribuir al controlador, consulta el proyecto. GitHub](https://github.com/aws/aws-app-mesh-controller-for-k8s)
El controlador también instala un webhook que inyecta los siguientes contenedores en los pods de Kubernetes etiquetados con el nombre que especifique.
+ **Proxy de App Mesh Envoy**: Envoy utiliza la configuración definida en el plano de control de App Mesh para determinar dónde enviar el tráfico de la aplicación.
+ **Administrador de rutas del proxy de App Mesh**: actualiza las reglas `iptables` del espacio de nombres de red de un pod que enrutan el tráfico entrante y saliente a través de Envoy. Este contenedor funciona como un contenedor init de Kubernetes dentro del pod.
## Requisitos previos
+ Comprensión previa de los conceptos de App Mesh. Para obtener más información, consulte [¿Qué es AWS App Mesh?](what-is-app-mesh.md).
+ Comprensión previa de los conceptos de Kubernetes. Para obtener más información, consulte [Qué es Kubernetes](https://kubernetes.io/docs/concepts/overview/what-is-kubernetes/) en la documentación de Kubernetes.
+ Un clúster de Kubernetes de existente. Si no dispone de un clúster existente, consulte [Introducción a Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/getting-started.html) en la *Guía del usuario de Amazon EKS*. Si ejecuta su propio clúster de Kubernetes en Amazon EC2, asegúrese de que Docker esté autenticado en el repositorio de Amazon ECR en el que se encuentra la imagen de Envoy. Para obtener más información, consulte la [Imagen de Envoy](https://docs.aws.amazon.com/app-mesh/latest/userguide/envoy.html), [Autenticación del registro](https://docs.aws.amazon.com/AmazonECR/latest/userguide/Registries.html#registry_auth) en la Guía del usuario de Amazon Elastic Container Registry y [Extracción de una imagen de un registro privado](https://kubernetes.io/docs/tasks/configure-pod-container/pull-image-private-registry/) en la documentación de Kubernetes.
+ App Mesh es compatible con los servicios de Linux que están registrados con DNS o con ambos. AWS Cloud Map Para utilizar esta guía de introducción, le recomendamos que tenga tres servicios existentes que estén registrados con DNS. En los procedimientos de este tema se presupone que los servicios existentes se llaman `serviceA`, `serviceB` y `serviceBv2`, y que todos los servicios son detectables a través de un espacio de nombres denominado `apps.local`.
Puede crear una malla de servicios y sus recursos incluso aunque los servicios no existan, pero no puede usar la malla hasta que haya implementado servicios reales.
+ La AWS CLI versión 1.18.116 o posterior o 2.0.38 o posterior instalada. [Para instalar o actualizar el AWS CLI, consulte Instalación del. AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html)
+ Un cliente `kubectl` configurado para comunicarse con el clúster de Kubernetes. Si utiliza Amazon Elastic Kubernetes Service, puede seguir las instrucciones para instalar `[kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html)` y configurar un archivo `[kubeconfig](https://docs.aws.amazon.com/eks/latest/userguide/create-kubeconfig.html)`.
+ Tiene instalada la versión 3.0 o posterior. Si no tiene instalado Helm, consulte [Uso de Helm con Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/helm.html) en la *Guía del usuario de Amazon EKS*.
+ Actualmente, Amazon EKS solo admite preferencias de IP solo `IPv4_ONLY` y solo `IPv6_ONLY`, ya que Amazon EKS actualmente solo admite pods capaces de atender solo el tráfico `IPv4` o solo el tráfico `IPv6`.
En los pasos restantes se presupone que los servicios reales se llaman `serviceA`, `serviceB` y `serviceBv2`, y que todos los servicios son detectables a través de un espacio de nombres denominado `apps.local`.
## Paso 1: Instalar los componentes de integración
Instale los componentes de integración una vez en cada clúster que aloja los pods que desee utilizar con App Mesh.
**Para instalar los componentes de integración**
1. Para los pasos restantes de este procedimiento es necesario un clúster sin una versión preliminar del controlador instalada. Si ha instalado una versión preliminar o no está seguro de si dispone de ella, puede descargar y ejecutar un script que compruebe si hay una versión preliminar instalada en el clúster.
```
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
```
Si el script devuelve `Your cluster is ready for upgrade. Please proceed to the installation instructions`, puede continuar con el siguiente paso. Si se devuelve un mensaje diferente, deberá completar los pasos de actualización para continuar. Para obtener más información sobre la actualización de una versión preliminar, consulte [Actualizar](https://github.com/aws/eks-charts/blob/master/stable/appmesh-controller/README.md#upgrade) en GitHub.
1. Agregue el repositorio `eks-charts` a Helm.
```
helm repo add eks https://aws.github.io/eks-charts
```
1. Instale las definiciones de recursos personalizados (CRD) de App Mesh Kubernetes.
```
kubectl apply -k "https://github.com/aws/eks-charts/stable/appmesh-controller/crds?ref=master"
```
1. Cree un espacio de nombres de Kubernetes para el controlador.
```
kubectl create ns appmesh-system
```
1. Establezca las siguientes variables para usarlas en los pasos posteriores. Reemplace `{{cluster-name}}` y `{{Region-code}}` por los valores del clúster existente.
```
export CLUSTER_NAME={{cluster-name}}
export AWS_REGION={{Region-code}}
```
1. (Opcional) Si desea ejecutar el controlador en Fargate, tiene que crear un perfil de Fargate. Si no tiene instalado `eksctl`, consulte [Instalación o actualización de `eksctl`](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html#installing-eksctl) en la *Guía del usuario de Amazon EKS*. Si prefiere crear el perfil mediante la consola, consulte [Creación de un perfil de Fargate](https://docs.aws.amazon.com/eks/latest/userguide/fargate-profile.html#create-fargate-profile) en la *Guía del usuario de Amazon EKS*.
```
eksctl create fargateprofile --cluster $CLUSTER_NAME --name {{appmesh-system}} --namespace {{appmesh-system}}
```
1. Cree un proveedor de identidad de OpenID Connect (OIDC) para su clúster. Si no tiene instalado `eksctl`, puede instalarlo siguiendo las instrucciones de [Instalación o actualización de `eksctl`](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html#installing-eksctl) en la *Guía del usuario de Amazon EKS*. Si prefiere crear el proveedor mediante la consola, consulte [Habilitación de roles de IAM para cuentas de servicio en su clúster](https://docs.aws.amazon.com/eks/latest/userguide/enable-iam-roles-for-service-accounts.html) en la *Guía del usuario de Amazon EKS*.
```
eksctl utils associate-iam-oidc-provider \
--region=$AWS_REGION \
--cluster $CLUSTER_NAME \
--approve
```
1. Cree un rol de IAM, asocie las 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 gestionadas [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)y vincúlelo a la cuenta de servicio de `appmesh-controller` Kubernetes. El rol permite al controlador añadir, quitar y cambiar recursos de App Mesh.
**nota**
El comando crea un rol de AWS IAM con un nombre generado automáticamente. No puede especificar el nombre de rol de IAM que se crea.
```
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
```
Si prefiere crear la cuenta de servicio mediante Consola de administración de AWS o AWS CLI, consulte [Creación de un rol y una política de IAM para su cuenta de servicio](https://docs.aws.amazon.com/eks/latest/userguide/create-service-account-iam-policy-and-role.html#create-service-account-iam-role) en la *Guía del usuario de Amazon EKS*. Si utiliza Consola de administración de AWS o AWS CLI para crear la cuenta, también debe asignar la función a una cuenta de servicio de Kubernetes. Para obtener más información, consulte [Especificación de un rol de IAM para su cuenta de servicio](https://docs.aws.amazon.com/eks/latest/userguide/specify-service-account-role.html) en la *Guía del usuario de Amazon EKS*.
1.
**Implemente el controlador de App Mesh. [Para ver una lista de todas las opciones de configuración, consulta Configuración en.](https://github.com/aws/eks-charts/blob/master/stable/appmesh-controller/README.md#configuration) GitHub**
1. Para implementar el controlador de App Mesh en un clúster privado, primero debe habilitar App Mesh y los puntos de conexión de Amazon VPC de detección de servicios en la subred privada enlazada. También debe establecer el `accountId`.
```
--set accountId=$AWS_ACCOUNT_ID
```
Para habilitar el rastreo de X-Ray en un clúster privado, habilite los puntos de conexión de Amazon VPC de X-Ray y Amazon ECR. El controlador usa `public.ecr.aws/xray/aws-xray-daemon:latest` de forma predeterminada, así que coloque esta imagen en una ubicación local y [colóquela en el repositorio de ECR personal](https://docs.aws.amazon.com/AmazonECR/latest/userguide/docker-push-ecr-image.html).
**nota**
Los [puntos de conexión de Amazon VPC](https://docs.aws.amazon.com/AmazonECR/latest/userguide/vpc-endpoints.html) actualmente no admiten los repositorios públicos de Amazon ECR.
El siguiente ejemplo muestra la implementación del controlador con configuraciones para 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}}
```
Compruebe si el daemon de X-Ray se ha inyectado correctamente al vincular la implementación de la aplicación con el nodo virtual o puerta de enlace.
Para obtener más información, consulte [Clústeres privados](https://docs.aws.amazon.com/eks/latest/userguide/private-clusters.html) en la *Guía del usuario de Amazon EKS*.
1. Implemente el controlador de App Mesh para otros clústeres. Para obtener una lista de todas las opciones de configuración, consulte [Configuración](https://github.com/aws/eks-charts/blob/master/stable/appmesh-controller/README.md#configuration) activada 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**
Si su familia de clústeres de Amazon EKS es `IPv6`, defina el nombre del clúster al implementar el controlador App Mesh añadiendo la siguiente opción al comando anterior `--set clusterName=$CLUSTER_NAME`.
**importante**
Si el clúster está en las regiones `me-south-1`, `ap-east-1`, `ap-southeast-3`, `eu-south-1`, `il-central-1` o `af-south-1`, debe añadir las siguientes opciones al comando anterior:
Sustituya {{account-id}} y {{Region-code}} por uno de los conjuntos de valores adecuados.
```
--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
[La imagen anterior se encuentra en URIs el registro de cambios.](https://github.com/aws/aws-app-mesh-controller-for-k8s/releases) GitHub Las AWS cuentas en las que están presentes las imágenes han cambiado de versión`v1.5.0`. Las versiones anteriores de las imágenes se alojan en cuentas de AWS que se encuentran en los [registros de imágenes de contenedores de Amazon](https://docs.aws.amazon.com/eks/latest/userguide/add-ons-images.html) de Amazon Elastic Kubernetes Service.
```
--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/aws-appmesh-proxy-route-manager:v7-prod
909464085924.dkr. ecr.ap-southeast-3.amazonaws.com/aws-appmesh-proxy-route-manager:v7-prod
422531588944.dkr. ecr.eu-south-1.amazonaws.com/aws-appmesh-proxy-route-manager:v7-prod
564877687649.dkr. ecr.il-central-1.amazonaws.com/aws-appmesh-proxy-route-manager:v7-prod
924023996002.dkr. ecr.af-south-1.amazonaws.com/aws-appmesh-proxy-route-manager:v7-prod
**importante**
Solo se admite el uso de la versión v1.9.0.0-prod o posterior con App Mesh.
1. Confirme que la versión del controlador es `v1.4.0` o posterior. Puede revisar el registro de cambios en el inicio [de sesión.](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**
Si ve el registro del contenedor en ejecución, puede ver una línea que incluye el siguiente texto, que puede omitirse de forma segura.
```
Neither -kubeconfig nor -master was specified. Using the inClusterConfig. This might not work.
```
## Paso 2: Implementar recursos de App Mesh
Cuando implementa una aplicación en Kubernetes, también tiene que crear los recursos personalizados de Kubernetes para que el controlador pueda crear los recursos de App Mesh correspondientes. El siguiente procedimiento lo ayuda a implementar recursos de App Mesh con algunas de sus características. Puedes encontrar ejemplos de manifiestos para implementar otras funciones de recursos de App Mesh en las `v1beta2` subcarpetas de muchas de las carpetas de funciones que aparecen en los [tutoriales de App Mesh](https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs) en. GitHub
**importante**
Una vez que el controlador cree un recurso de App Mesh, recomendamos que solo realice cambios en el recurso de App Mesh (o que lo elimine) mediante el controlador. Si realiza cambios o elimina el recurso mediante App Mesh, el controlador no cambiará ni volverá a crear el recurso de App Mesh modificado o eliminado durante diez horas, de forma predeterminada. Puede configurar esta duración para que sea inferior. [Para obtener más información, consulte Configuración en.](https://github.com/aws/eks-charts/blob/master/stable/appmesh-controller/README.md#configuration) GitHub
**Para implementar recursos de App Mesh**
1. Cree un espacio de nombres de Kubernetes en el que implementar recursos de App Mesh.
1. Guarde el siguiente contenido en un archivo llamado `namespace.yaml` en el equipo.
```
apiVersion: v1
kind: Namespace
metadata:
name: {{my-apps
}} labels:
mesh: {{my-mesh}}
appmesh.k8s.aws/sidecarInjectorWebhook: enabled
```
1. Cree el espacio de nombres.
```
kubectl apply -f namespace.yaml
```
1. Cree una malla de servicios de App Mesh.
1. Guarde el siguiente contenido en un archivo llamado `mesh.yaml` en el equipo. El archivo se utiliza para crear un recurso de malla denominado `{{my-mesh}}`. Una malla de servicios es un límite lógico para el tráfico de red entre los servicios que residen dentro de ella.
```
apiVersion: appmesh.k8s.aws/v1beta2
kind: Mesh
metadata:
name: {{my-mesh}}
spec:
namespaceSelector:
matchLabels:
mesh: {{my-mesh}}
```
1. Cree la malla.
```
kubectl apply -f mesh.yaml
```
1. Consulte los detalles del recurso de malla Kubernetes que se ha creado.
```
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. Consulte los detalles sobre la malla de servicios de App Mesh que creó el controlador.
```
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. Cree un nodo virtual de App Mesh. Un nodo virtual actúa como un puntero lógico a una implementación de Kubernetes.
1. Guarde el siguiente contenido en un archivo llamado `virtual-node.yaml` en el equipo. El archivo se utilizará para crear un nodo virtual de App Mesh denominado `{{my-service-a}}` en el espacio de nombres {{`my-apps`}}. El nodo virtual representa un servicio de Kubernetes que se crea en un paso posterior. El valor de `hostname` es el nombre de host de DNS completo del servicio real que representa este nodo virtual.
```
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}}
```
Los nodos virtuales tienen capacidades, como el end-to-end cifrado y las comprobaciones de estado, que no se tratan en este tutorial. Para obtener más información, consulte [Nodos virtuales](virtual_nodes.md). Para ver todas las configuraciones disponibles para un nodo virtual que puede establecer en la especificación anterior, ejecute el siguiente comando.
```
aws appmesh create-virtual-node --generate-cli-skeleton yaml-input
```
1. Implemente el nodo virtual.
```
kubectl apply -f virtual-node.yaml
```
1. Consulte los detalles del recurso del nodo virtual Kubernetes que se ha creado.
```
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. Consulte los detalles del nodo virtual que el controlador creó en App Mesh.
**nota**
Aunque el nombre del nodo virtual creado en Kubernetes es `{{my-service-a}}`, el nombre del nodo virtual creado en App Mesh es `{{my-service-a_my-apps}}`. El controlador anexa el nombre del espacio de nombres de Kubernetes al nombre del nodo virtual de App Mesh cuando crea el recurso de App Mesh. El nombre del espacio de nombres se agrega porque en Kubernetes se pueden crear nodos virtuales con el mismo nombre en diferentes espacios de nombres, pero en App Mesh un nombre de nodo virtual debe ser único dentro de una malla.
```
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. Cree un enrutador virtual de App Mesh. Los routers virtuales controlan el tráfico de uno o más servicios virtuales dentro de la malla.
1. Guarde el siguiente contenido en un archivo llamado `virtual-router.yaml` en el equipo. El archivo se utiliza para crear un enrutador virtual para dirigir el tráfico al nodo virtual denominado `my-service-a` que se creó en el paso anterior. El controlador crea el enrutador virtual de App Mesh y los recursos de la ruta. Puede especificar muchas más capacidades para sus rutas y utilizar protocolos distintos de `http`. Para obtener más información, consulte [Enrutadores virtuales](virtual_routers.md) y [Rutas](routes.md). Tenga en cuenta que el nombre del nodo virtual al que se hace referencia es el nombre del nodo virtual de Kubernetes, no el nombre del nodo virtual de App Mesh que ha creado el controlador en App Mesh.
```
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 las configuraciones disponibles para un enrutador virtual que puede establecer en la especificación anterior, ejecute el siguiente comando.
```
aws appmesh create-virtual-router --generate-cli-skeleton yaml-input
```
Para ver todas las configuraciones disponibles para una ruta que puede establecer en la especificación anterior, ejecute el siguiente comando.
```
aws appmesh create-route --generate-cli-skeleton yaml-input
```
1. Implemente el enrutador virtual.
```
kubectl apply -f virtual-router.yaml
```
1. Consulte el recurso del enrutador virtual Kubernetes que se ha creado.
```
kubectl describe virtualrouter {{my-service-a-virtual-router}} -n {{my-apps}}
```
Salida abreviada
```
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. Consulte el recurso del enrutador virtual que el controlador creó en App Mesh. Especifique `my-service-a-virtual-router_my-apps` para `name`, porque cuando el controlador creó el enrutador virtual en App Mesh, anexó el nombre del espacio de nombres Kubernetes al nombre del enrutador 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. Consulte el recurso de la ruta que el controlador creó en App Mesh. No se creó un recurso de ruta en Kubernetes porque la ruta forma parte de la configuración del enrutador virtual en Kubernetes. La información de la ruta se muestra en los detalles del recurso Kubernetes en el subpaso `c`. El controlador no anexó el nombre del espacio de nombres de Kubernetes al nombre de la ruta de App Mesh al crear la ruta en App Mesh porque los nombres de ruta son exclusivos para un enrutador 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. Cree un servicio virtual de App Mesh. Un servicio virtual es una abstracción de un servicio real que se proporcionan mediante un nodo virtual directa o indirectamente a través de un router virtual. Los servicios dependientes llaman al servicio virtual por su nombre. Aunque el nombre no es pertinente para App Mesh, se recomienda asignar al servicio virtual el nombre de dominio completo del servicio real al que hace referencia. Al nombrar sus servicios virtuales de esa manera, no tendrá que cambiar el código de aplicación para que haga referencia a un nombre distinto. Las solicitudes se dirigen al nodo virtual o enrutador virtual que se especifica como proveedor del servicio virtual.
1. Guarde el siguiente contenido en un archivo llamado `virtual-service.yaml` en el equipo. El archivo se utiliza para crear un servicio virtual que utilice un proveedor de enrutador virtual para dirigir el tráfico al nodo virtual denominado `my-service-a` que se creó en el paso anterior. El valor de `awsName` en `spec` es el nombre de dominio completo (FQDN) del servicio de Kubernetes real que abstrae este servicio virtual. El servicio Kubernetes se crea en [Paso 3: Crear o actualizar servicios](#create-update-services). Para obtener más información, consulte [Servicios virtuales](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 las configuraciones disponibles para un servicio virtual que puede establecer en la especificación anterior, ejecute el siguiente comando.
```
aws appmesh create-virtual-service --generate-cli-skeleton yaml-input
```
1. Cree el servicio virtual.
```
kubectl apply -f virtual-service.yaml
```
1. Consulte los detalles del recurso del servicio virtual Kubernetes que se ha creado.
```
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. Consulte los detalles del recurso del servicio virtual que el controlador creó en App Mesh. El controlador de Kubernetes no anexó el nombre del espacio de nombres de Kubernetes al nombre del servicio virtual de App Mesh al crear el servicio virtual en App Mesh, porque el nombre del servicio virtual es un FQDN único.
```
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"
}
}
```
Aunque no se trata en este tutorial, el controlador también puede implementar [Puertas de enlace virtuales](virtual_gateways.md) y [Rutas de puertas de enlace](gateway-routes.md) de App Mesh. Para ver un tutorial sobre la implementación de estos recursos con el controlador, consulta [Cómo configurar la puerta de enlace entrante](https://github.com/aws/aws-app-mesh-examples/tree/main/walkthroughs/howto-k8s-ingress-gateway) o un [ejemplo de manifiesto](https://github.com/aws/aws-app-mesh-examples/blob/main/walkthroughs/howto-k8s-ingress-gateway/v1beta2/manifest.yaml.template) que incluya los recursos. GitHub
## Paso 3: Crear o actualizar servicios
Todos los pods que desee usar con App Mesh deben tener los contenedores sidecar de App Mesh asociados a ellos. El inyector añade automáticamente los contenedores sidecar a cualquier pod implementado con una etiqueta que especifique.
1. Habilite la autorización de proxy. Recomendamos que habilite cada implementación de Kubernetes para transmitir solo la configuración de su propio nodo virtual de App Mesh.
1. Guarde el siguiente contenido en un archivo llamado `proxy-auth.json` en el equipo. Asegúrese de reemplazarla por la {{alternate-colored values}} suya propia.
------
#### [ 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. Creación de la política.
```
aws iam create-policy --policy-name {{my-policy}} --policy-document file://proxy-auth.json
```
1. Cree un rol de IAM, asocie la política que creó en el paso anterior, cree una cuenta de servicio de Kubernetes y enlace la política a la cuenta de servicio de Kubernetes. El rol permite al controlador añadir, quitar y cambiar recursos de 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
```
Si prefiere crear la cuenta de servicio mediante Consola de administración de AWS o AWS CLI, consulte [Creación de un rol y una política de IAM para su cuenta de servicio](https://docs.aws.amazon.com/eks/latest/userguide/create-service-account-iam-policy-and-role.html#create-service-account-iam-role) en la *Guía del usuario de Amazon EKS*. Si utiliza Consola de administración de AWS o AWS CLI para crear la cuenta, también debe asignar la función a una cuenta de servicio de Kubernetes. Para obtener más información, consulte [Especificación de un rol de IAM para su cuenta de servicio](https://docs.aws.amazon.com/eks/latest/userguide/specify-service-account-role.html) en la *Guía del usuario de Amazon EKS*.
1. (Opcional) Si desea realizar la implementación en pods de Fargate, debe crear un perfil de Fargate. Si no tiene instalado `eksctl`, puede instalarlo siguiendo las instrucciones de [Instalación o actualización de `eksctl`](https://docs.aws.amazon.com/eks/latest/userguide/eksctl.html#installing-eksctl) en la *Guía del usuario de Amazon EKS*. Si prefiere crear el perfil mediante la consola, consulte [Creación de un perfil de Fargate](https://docs.aws.amazon.com/eks/latest/userguide/fargate-profile.html#create-fargate-profile) en la *Guía del usuario de Amazon EKS*.
```
eksctl create fargateprofile --cluster {{my-cluster}} --region {{Region-code}} --name {{my-service-a}} --namespace {{my-apps}}
```
1. Cree un servicio y una implementación de Kubernetes. Si tiene una implementación existente que desea usar con App Mesh, debe implementar un nodo virtual, como hizo en el paso secundario `3` del [Paso 2: Implementar recursos de App Mesh](#configure-app-mesh). Actualice la implementación para asegurarse de que su etiqueta coincida con la etiqueta que configuró en el nodo virtual, de modo que los contenedores sidecar se añadan automáticamente a los pods y estos se vuelvan a implementar.
1. Guarde el siguiente contenido en un archivo llamado `example-service.yaml` en el equipo. Si cambia el nombre del espacio de nombres y utiliza pods de Fargate, asegúrese de que el nombre del espacio de nombres coincida con el que definió en su perfil de 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**
El valor de `app` `matchLabels` `selector` en la especificación debe coincidir con el valor que especificó al crear el nodo virtual en el subpaso `3` de [Paso 2: Implementar recursos de App Mesh](#configure-app-mesh). De lo contrario, los contenedores sidecar no se inyectarán en el pod. En el ejemplo anterior, el valor de la etiqueta es `my-app-1`. Si implementa una puerta de enlace virtual en lugar de un nodo virtual, el manifiesto `Deployment` solo debe incluir el contenedor de Envoy. Para obtener más información acerca de la imagen que debe utilizar, consulte [Imagen de Envoy](envoy.md). [Para ver un ejemplo de manifiesto, consulta el ejemplo de implementación en.](https://github.com/aws/aws-app-mesh-examples/blob/main/walkthroughs/howto-k8s-ingress-gateway/v1beta2/manifest.yaml.template#L585) GitHub
1. Implemente el servicio.
```
kubectl apply -f {{example-service.yaml}}
```
1. Consulte el servicio y la implementación.
```
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. Consulte los detalles de uno de los pods que se ha implementado.
```
kubectl -n {{my-apps}} describe pod {{my-service-a-54776556f6-2cxd9}}
```
Salida abreviada
```
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
```
En el resultado anterior, puede ver que el controlador ha añadido los contenedores `proxyinit` y `envoy` al pod. Si implementó el servicio de ejemplo en Fargate, el controlador agregó el contenedor `envoy` al pod, pero no el contenedor `proxyinit`.
1. (Opcional) Instale complementos como Prometheus, Grafana, Jaeger y AWS X-Ray Datadog. Para obtener más información, consulta los [complementos de App Mesh](https://github.com/aws/eks-charts#app-mesh-add-ons) GitHub y la sección [Observabilidad](https://docs.aws.amazon.com/app-mesh/latest/userguide/observability.html) de la Guía del usuario de App Mesh.
**nota**
Para ver más ejemplos y tutoriales de App Mesh, consulte el [repositorio de ejemplos de App Mesh](https://github.com/aws/aws-app-mesh-examples).
## Paso 4: Limpiar
Elimine todos los recursos de ejemplo creados en este tutorial. El controlador también elimina los recursos creados en la malla de servicios de App Mesh `my-mesh`.
```
kubectl delete namespace {{my-apps}}
```
Si ha creado un perfil de Fargate para el servicio de ejemplo, elimínelo.
```
eksctl delete fargateprofile --name {{my-service-a}} --cluster {{my-cluster}} --region {{Region-code}}
```
Elimine la malla.
```
kubectl delete mesh {{my-mesh}}
```
(Opcional) Puede eliminar los componentes de integración de Kubernetes.
```
helm delete appmesh-controller -n appmesh-system
```
(Opcional) Si implementó los componentes de integración de Kubernetes en Fargate, elimine el perfil de Fargate.
```
eksctl delete fargateprofile --name {{appmesh-system}} --cluster {{my-cluster}} --region {{Region-code}}
```