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.
# Introducción a App Mesh
**importante**
Aviso de fin de soporte: el 30 de septiembre de 2026, AWS suspenderemos el 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).
Puede usar App Mesh con aplicaciones que implemente en Amazon ECS, Kubernetes (que implemente en sus propias instancias de Amazon EC2 o que se ejecuten en Amazon EKS) y Amazon EC2. Para empezar a usar App Mesh, seleccione uno de los servicios en los que tenga implementadas las aplicaciones que desee usar con App Mesh. Siempre puede habilitar las aplicaciones en los demás servicios para que funcionen también con App Mesh después de leer una de las Guías de introducción.
**Topics**
+ [Primeros pasos con AWS App Mesh Amazon ECS](getting-started-ecs.md)
+ [Primeros pasos con AWS App Mesh Kubernetes](getting-started-kubernetes.md)
+ [Introducción a AWS App Mesh Amazon EC2](getting-started-ec2.md)
+ [Ejemplos de App Mesh](examples.md)
# Primeros pasos con AWS App Mesh Amazon ECS
**importante**
Aviso de fin del soporte: el 30 de septiembre de 2026, AWS suspenderemos el 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).
Este tema le ayuda a utilizarlo AWS App Mesh con un servicio real que se ejecuta en Amazon ECS. Este tutorial abarca las características básicas de varios tipos de recursos de App Mesh.
## Escenario
Para ilustrar cómo usar App Mesh, suponga que tiene una aplicación con las siguientes características:
+ Consta de dos servicios denominados `serviceA` y `serviceB`.
+ Ambos servicios están registrados en un espacio de nombres denominado `apps.local`.
+ `ServiceA` se comunica con `serviceB` a través de HTTP/2, puerto 80.
+ Ya ha implementado la versión 2 de `serviceB` y la ha registrado con el nombre `serviceBv2` en el espacio de nombres `apps.local`.
Tiene los siguientes requisitos:
+ Desea enviar el 75 por ciento del tráfico desde `serviceA` `serviceB` y el 25 por ciento del tráfico hacia `serviceBv2` First. Si solo envías el 25 por ciento a`serviceBv2`, puedes validar que está libre de errores antes de enviar el 100 por ciento del tráfico desde allí`serviceA`.
+ Desea poder ajustar fácilmente la proporción del tráfico para que el 100 % del tráfico vaya hacia `serviceBv2` una vez que se demuestre que es de confianza. Una vez que se envía todo el tráfico a `serviceBv2`, desea suspender `serviceB`.
+ No quiere tener que cambiar ningún código de aplicación existente o registro de detección de servicios para que sus servicios reales cumplan los requisitos anteriores.
Para satisfacer sus requisitos, ha decidido crear una malla de servicios de App Mesh con servicios virtuales, nodos virtuales, un enrutador virtual y una ruta. Después de implementar la malla, actualiza los servicios para utilizar el proxy de Envoy. Una vez actualizados, sus servicios se comunican entre sí a través del proxy de Envoy en lugar de directamente.
## Requisitos previos
**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).
+ 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).
+ Una comprensión actual de los ECSs conceptos de Amazon. Para obtener más información, consulte [Qué es Amazon ECS](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/Welcome.html) en la Guía para desarrolladores de Amazon Elastic Container Service.
+ 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. Para obtener más información acerca de la detección de servicios en Amazon ECS, consulte [Detección de servicios](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-discovery.html). Para crear un servicio de Amazon ECS con la detección de servicios, consulte [Tutorial: Creación de un servicio mediante la detección de servicios](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service-discovery.html). Si aún no tiene los servicios en ejecución, puede [Crear un servicio de Amazon ECS mediante la detección de servicios](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/create-service-discovery.html).
## Paso 1: Crear una malla y un servicio virtual
Una malla de servicios es un límite lógico para el tráfico de red entre los servicios que residen dentro de ella. Para obtener más información, consulte [Mallas de servicios](meshes.md). Un servicio virtual es una abstracción de un servicio real. Para obtener más información, consulte [Servicios virtuales](virtual_services.md).
Cree los siguientes recursos :
+ Una malla denominada `apps`, ya que todos los servicios del escenario están registrados en el espacio de nombres `apps.local`.
+ Un servicio virtual llamado `serviceb.apps.local`, ya que el servicio virtual representa un servicio que se puede detectar con ese nombre y no desea cambiar el código para hacer referencia a otro nombre. Un servicio virtual llamado `servicea.apps.local` se agrega en un paso posterior.
Puedes usar la AWS CLI versión 1.18.116 Consola de administración de AWS o superior o la 2.0.38 o superior para completar los siguientes pasos. Si utiliza el AWS CLI, utilice el `aws --version` comando para comprobar la versión instalada. AWS CLI Si no tiene instalada 1.18.116 o posterior o bien la 2.0.38 o posterior, debe [instalar o actualizar la AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/appmesh/cli-chap-install.html). Seleccione la pestaña de la herramienta que desea utilizar.
------
#### [ Consola de administración de AWS ]
1. Abre el asistente de primera ejecución de la consola App Mesh al comenzar [https://console.aws.amazon.com/appmesh/.](https://console.aws.amazon.com/appmesh/get-started)
1. Para **Nombre de malla**, escriba **apps**.
1. En **Nombre del servicio virtual**, escriba **serviceb.apps.local**.
1. Para continuar, elija **Siguiente**.
------
#### [ AWS CLI ]
1. Cree una malla con el comando `[create-mesh](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-mesh.html)`.
```
aws appmesh create-mesh --mesh-name apps
```
1. Cree un servicio virtual con el 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 {}
```
------
## Paso 2: Crear un nodo virtual
Un nodo virtual actúa como un puntero lógico a un servicio real. Para obtener más información, consulte [Nodos virtuales](virtual_nodes.md).
Cree un nodo virtual denominado `serviceB`, ya que uno de los nodos virtuales representa el servicio real denominado `serviceB`. El servicio real que representa el nodo virtual es detectable a través de `DNS` con un nombre de host de `serviceb.apps.local`. Como alternativa, puede descubrir los servicios reales utilizando. AWS Cloud Map El nodo virtual atenderá el tráfico utilizando el protocolo HTTP/2 en el puerto 80. También se admiten otros protocolos, así como comprobaciones de estado. Creará nodos virtuales para `serviceA` y `serviceBv2` en un paso posterior.
------
#### [ Consola de administración de AWS ]
1. En **Nombre del nodo virtual**, escriba **serviceB**.
1. En **Método de detección de servicios**, elija **DNS** y escriba **serviceb.apps.local** en **Nombre de host DNS**.
1. En **Configuración del agente de escucha**, elija **http2** en **Protocolo** y escriba **80** en **Puerto**.
1. Para continuar, elija **Siguiente**.
------
#### [ AWS CLI ]
1. Cree un archivo denominado `create-virtual-node-serviceb.json` con el siguiente contenido:
```
{
"meshName": "apps",
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http2"
}
}
],
"serviceDiscovery": {
"dns": {
"hostname": "serviceB.apps.local"
}
}
},
"virtualNodeName": "serviceB"
}
```
1. Cree el nodo virtual con el [create-virtual-node](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-virtual-node.html)comando utilizando el archivo JSON como entrada.
```
aws appmesh create-virtual-node --cli-input-json file://create-virtual-node-serviceb.json
```
------
## Paso 3: Crear un enrutador virtual y una ruta
Los routers virtuales enrutan el tráfico de uno o más servicios virtuales dentro de la malla. Para obtener más información, consulte [Enrutadores virtuales](virtual_routers.md) y [Rutas](routes.md).
Cree los siguientes recursos :
+ Un enrutador virtual llamado `serviceB`, ya que el servicio virtual `serviceB.apps.local` no inicia la comunicación saliente con ningún otro servicio. Recuerde que el servicio virtual que creó anteriormente es una abstracción de su servicio `serviceb.apps.local` real. El servicio virtual envía tráfico al router virtual. El enrutador virtual escucha el tráfico utilizando el protocolo HTTP/2 en el puerto 80. También se admiten otros protocolos.
+ Una ruta llamada `serviceB`. Enruta el cien por cien de su tráfico al nodo virtual `serviceB`. La ponderación se realiza en un paso posterior una vez que haya añadido el nodo virtual `serviceBv2`. Aunque no se incluye en esta guía, puede agregar criterios de filtro adicionales para la ruta y agregar una política de reintento para que el proxy de Envoy realice varios intentos de enviar tráfico a un nodo virtual cuando experimenta un problema de comunicación.
------
#### [ Consola de administración de AWS ]
1. En **Nombre del enrutador virtual**, escriba **serviceB**.
1. En **Configuración del agente de escucha**, elija **http2** en **Protocolo** y especifique **80** en **Puerto**.
1. En **Nombre de ruta**, escriba **serviceB**.
1. En **Tipo de ruta**, elija **http2**.
1. En **Nombre de nodo virtual**, en **Configuración de destino**, seleccione `serviceB` y escriba **100** para **Ponderación**.
1. En **Configuración de coincidencia**, elija un **Método**.
1. Para continuar, elija **Siguiente**.
------
#### [ AWS CLI ]
1. Cree un router virtual.
1. Cree un archivo denominado `create-virtual-router.json` con el siguiente contenido:
```
{
"meshName": "apps",
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http2"
}
}
]
},
"virtualRouterName": "serviceB"
}
```
1. Cree el router virtual con el [create-virtual-router](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-virtual-router.html)comando utilizando el archivo JSON como entrada.
```
aws appmesh create-virtual-router --cli-input-json file://create-virtual-router.json
```
1. Cree una ruta.
1. Cree un archivo denominado `create-route.json` con el siguiente contenido:
```
{
"meshName" : "apps",
"routeName" : "serviceB",
"spec" : {
"httpRoute" : {
"action" : {
"weightedTargets" : [
{
"virtualNode" : "serviceB",
"weight" : 100
}
]
},
"match" : {
"prefix" : "/"
}
}
},
"virtualRouterName" : "serviceB"
}
```
1. Cree la ruta con el comando [create-route](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-route.html) utilizando el archivo JSON como entrada.
```
aws appmesh create-route --cli-input-json file://create-route.json
```
------
## Paso 4: Revisar y crear
Revise la configuración comparándola con las instrucciones anteriores.
------
#### [ Consola de administración de AWS ]
Elija **Editar** si necesita realizar cambios en cualquier sección. Una vez esté satisfecho con la configuración, elija **Crear malla**.
La pantalla **Estado** muestra todos los recursos de malla que se han creado. Puede ver los recursos creados en la consola seleccionando **Ver malla**.
------
#### [ AWS CLI ]
Revise la configuración de la malla que creó con el comando [describe-mesh](https://docs.aws.amazon.com/cli/latest/reference/appmesh/describe-mesh.html).
```
aws appmesh describe-mesh --mesh-name apps
```
Revise la configuración del servicio virtual que creó con el [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 la configuración del nodo virtual que creó con el [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 la configuración del router virtual que creó con el [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 la configuración de la ruta que creó con el 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
```
------
## Paso 5: Crear recursos adicionales
Para completar el escenario, debe:
+ Crear un nodo virtual denominado `serviceBv2` y otro denominado `serviceA`. Ambos nodos virtuales escuchan las solicitudes a través del puerto HTTP/2 80. Para el nodo virtual `serviceA`, configure un backend de `serviceb.apps.local`. Todo el tráfico saliente del nodo virtual `serviceA` se envía al servicio virtual denominado `serviceb.apps.local`. Aunque no se trata en esta guía, también puede especificar una ruta de acceso de archivo en la que escribir registros de acceso para un nodo virtual.
+ Cree un servicio virtual adicional llamado `servicea.apps.local`, que envíe todo el tráfico directamente al nodo virtual `serviceA`.
+ Actualizar la ruta de `serviceB` que creó en un paso anterior para enviar el 75 % de su tráfico al nodo virtual `serviceB` y el 25 % de su tráfico al nodo virtual `serviceBv2`. Con el tiempo, puede continuar modificando las proporciones hasta que `serviceBv2` reciba el 100 % del tráfico. Una vez que se envíe todo el tráfico hacia `serviceBv2`, puede cerrar y suspender el nodo virtual `serviceB` y el servicio real. Cuando cambia las ponderaciones, el código no requiere ninguna modificación, ya que los nombres del servicio real y virtual `serviceb.apps.local` no cambian. Recuerde que el servicio virtual `serviceb.apps.local` envía tráfico al router virtual, que enruta el tráfico a los nodos virtuales. Los nombres de detección de servicios para los nodos virtuales se pueden cambiar en cualquier momento.
------
#### [ Consola de administración de AWS ]
1. En el panel de navegación izquierdo, seleccione **Mallas**.
1. Seleccione la malla `apps` que creó en un paso anterior.
1. En el panel de navegación izquierdo, seleccione **Nodos virtuales**.
1. Elija **Crear nodo virtual**.
1. En **Nombre del nodo virtual**, escriba **serviceBv2**, en **Método de detección de servicios**, elija **DNS**, y en **Nombre de host DNS** escriba **servicebv2.apps.local**.
1. En **Configuración del agente de escucha**, seleccione **http2** para **Protocolo** y escriba **80** para **Puerto**.
1. Elija **Crear nodo virtual**.
1. Elija de nuevo **Crear nodo virtual**. Escriba **serviceA** en el **Nombre del nodo virtual**. En **Método de detección de servicios**, elija **DNS** y en **Nombre de host DNS**, escriba **servicea.apps.local**.
1. En **Escriba un nombre de servicio virtual**, en **Nuevo backend**, escriba **serviceb.apps.local**.
1. En **Configuración del agente de escucha**, elija **http2** para **Protocolo**, escriba **80** para **Puerto** y, a continuación, elija **Crear nodo virtual**.
1. En el panel de navegación izquierdo, seleccione** Routers virtuales** y, a continuación, seleccione el router virtual `serviceB` de la lista.
1. En **Rutas**, seleccione la ruta llamada `ServiceB` que creó en un paso anterior y elija **Editar**.
1. En **Destinos**, **Nombre del nodo virtual**, cambie el valor de **Ponderación** de `serviceB` a **75**.
1. Elija **Agregar objetivo**, elija `serviceBv2` en la lista desplegable y establezca el valor de **Ponderación** en **25**.
1. Seleccione **Save**.
1. En el panel de navegación izquierdo, seleccione** Servicios virtuales** y, a continuación, elija **Crear servicio virtual**.
1. Escriba **servicea.apps.local** en **Nombre del servicio virtual**, seleccione **Nodo virtual** en **Proveedor**, seleccione `serviceA` en **Nodo virtual** y, a continuación, elija **Crear servicio virtual.**
------
#### [ AWS CLI ]
1. Cree el nodo virtual `serviceBv2`.
1. Cree un archivo denominado `create-virtual-node-servicebv2.json` con el siguiente contenido:
```
{
"meshName": "apps",
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http2"
}
}
],
"serviceDiscovery": {
"dns": {
"hostname": "serviceBv2.apps.local"
}
}
},
"virtualNodeName": "serviceBv2"
}
```
1. Cree el nodo virtual.
```
aws appmesh create-virtual-node --cli-input-json file://create-virtual-node-servicebv2.json
```
1. Cree el nodo virtual `serviceA`.
1. Cree un archivo denominado `create-virtual-node-servicea.json` con el siguiente contenido:
```
{
"meshName" : "apps",
"spec" : {
"backends" : [
{
"virtualService" : {
"virtualServiceName" : "serviceb.apps.local"
}
}
],
"listeners" : [
{
"portMapping" : {
"port" : 80,
"protocol" : "http2"
}
}
],
"serviceDiscovery" : {
"dns" : {
"hostname" : "servicea.apps.local"
}
}
},
"virtualNodeName" : "serviceA"
}
```
1. Cree el nodo virtual.
```
aws appmesh create-virtual-node --cli-input-json file://create-virtual-node-servicea.json
```
1. Actualice el servicio virtual `serviceb.apps.local` que creó en un paso anterior para enviar su tráfico al router virtual `serviceB`. Cuando el servicio virtual se creó originalmente, no envió tráfico a ninguna parte, ya que el router virtual `serviceB` aún no se había creado.
1. Cree un archivo denominado `update-virtual-service.json` con el siguiente contenido:
```
{
"meshName" : "apps",
"spec" : {
"provider" : {
"virtualRouter" : {
"virtualRouterName" : "serviceB"
}
}
},
"virtualServiceName" : "serviceb.apps.local"
}
```
1. Actualice el servicio virtual con el [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. Actualice la ruta `serviceB` que creó en un paso anterior.
1. Cree un archivo denominado `update-route.json` con el siguiente contenido:
```
{
"meshName" : "apps",
"routeName" : "serviceB",
"spec" : {
"http2Route" : {
"action" : {
"weightedTargets" : [
{
"virtualNode" : "serviceB",
"weight" : 75
},
{
"virtualNode" : "serviceBv2",
"weight" : 25
}
]
},
"match" : {
"prefix" : "/"
}
}
},
"virtualRouterName" : "serviceB"
}
```
1. Actualice la ruta con el 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. Cree el servicio virtual `serviceA`.
1. Cree un archivo denominado `create-virtual-servicea.json` con el siguiente contenido:
```
{
"meshName" : "apps",
"spec" : {
"provider" : {
"virtualNode" : {
"virtualNodeName" : "serviceA"
}
}
},
"virtualServiceName" : "servicea.apps.local"
}
```
1. Cree el servicio virtual.
```
aws appmesh create-virtual-service --cli-input-json file://create-virtual-servicea.json
```
------
**Resumen de malla**
Antes de crear la malla de servicio, tenía tres servicios reales denominados `servicea.apps.local`, `serviceb.apps.local` y `servicebv2.apps.local`. Además de los servicios reales, ahora tiene una malla de servicio que contiene los siguientes recursos que representan los servicios reales:
+ Dos servicios virtuales. El proxy envía todo el tráfico desde el servicio virtual `servicea.apps.local` al servicio virtual `serviceb.apps.local` a través de un router virtual.
+ Tres nodos virtuales denominados `serviceA`, `serviceB` y `serviceBv2`. El proxy de Envoy utiliza la información de detección de servicios configurada para los nodos virtuales para buscar las direcciones IP de los servicios reales.
+ Un router virtual con una ruta que indica al proxy de Envoy que enrute el 75 % del tráfico entrante al nodo virtual `serviceB` y el 25 % del tráfico al nodo virtual `serviceBv2`.
## Paso 6: Actualizar los servicios
Después de crear su malla, debe realizar las siguientes tareas:
+ Autorice al proxy de Envoy que implementa con cada tarea de Amazon ECS a que lea la configuración de uno o más nodos virtuales. Para obtener más información acerca de cómo autorizar el proxy, consulte [Autorización del proxy](https://docs.aws.amazon.com/app-mesh/latest/userguide/proxy-authorization.html).
+ Actualice cada una de sus definiciones de tareas de Amazon ECS para que utilicen el proxy de Envoy.
**Credenciales**
El contenedor Envoy requiere AWS Identity and Access Management credenciales para firmar las solicitudes que se envían al servicio App Mesh. Para las tareas de Amazon ECS implementadas con el tipo de lanzamiento de Amazon EC2, las credenciales pueden provenir del [rol de instancia](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/instance_IAM_role.html) o de un [rol de IAM de la tarea](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html). Las tareas de Amazon ECS implementadas con Fargate en contenedores de Linux no tienen acceso al servidor de metadatos de Amazon EC2 que proporciona las credenciales del perfil de IAM de la instancia. Para proporcionar las credenciales, debe asociar un rol de tarea de IAM a cualquier tarea implementada con el tipo de contenedor Fargate en Linux.
Si una tarea se implementa con el tipo de lanzamiento de Amazon EC2 y se bloquea el acceso al servidor de metadatos de Amazon EC2, tal y como se describe en la anotación *Importante* en [Rol de IAM para tareas](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html), también debe asociarse a la tarea un rol de IAM de tarea. El rol que asigne a la instancia o tarea debe tener una política de IAM asociada como se describe en [Autorización de proxy](https://docs.aws.amazon.com/app-mesh/latest/userguide/proxy-authorization.html).
**Para actualizar la definición de la tarea mediante el AWS CLI**
Utiliza el AWS CLI comando Amazon ECS [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). El ejemplo de definición de tarea que aparece a continuación muestra cómo configurar App Mesh para su servicio.
**nota**
La configuración de App Mesh para Amazon ECS a través de la consola no está disponible.
### json de definición de tarea
**Configuración del proxy**
Para configurar su servicio de Amazon ECS para que utilice App Mesh, la definición de tarea del servicio debe tener la siguiente sección de configuración de proxy. Establezca la configuración de proxy `type` en `APPMESH` y `containerName` en `envoy`. Establezca los siguientes valores de propiedad según corresponda.
`IgnoredUID`
El proxy de Envoy no enruta el tráfico de los procesos que utilizan este ID de usuario. Puede elegir cualquier identificador de usuario que desee para este valor de propiedad, pero este identificador debe ser el mismo que el ID de `user` del contenedor de Envoy en la definición de tarea. Este emparejamiento permite a Envoy pasar por alto su propio tráfico sin utilizar el proxy. Nuestros ejemplos utilizan `1337` con fines históricos.
`ProxyIngressPort`
Este es el puerto de entrada del contenedor de proxy de Envoy. Ajuste este valor en `15000`.
`ProxyEgressPort`
Este es el puerto de salida del contenedor de proxy de Envoy. Ajuste este valor en `15001`.
`AppPorts`
Especifique los puertos de entrada de escucha de los contenedores de aplicación. En este ejemplo, el contenedor de aplicación escucha en el puerto `9080`. El puerto que especifique debe coincidir con el puerto configurado en el agente de escucha de nodo virtual.
`EgressIgnoredIPs`
Envoy no utiliza un proxy para el tráfico en estas direcciones IP. Establezca este valor en `169.254.170.2,169.254.169.254`, que ignora el servidor de metadatos de Amazon EC2 y el punto de conexión de metadatos de la tarea de Amazon ECS. El punto de conexión de metadatos proporciona roles de IAM para las credenciales de tareas. Puede añadir direcciones adicionales.
`EgressIgnoredPorts`
Puede añadir una lista de puertos separados por comas. Envoy no utiliza un proxy para el tráfico en estas direcciones IP. El puerto 22 no se tiene en cuenta aunque no aparezca ningún puerto.
El número máximo de puertos de salida que se pueden ignorar es 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"
}
]
}
```
**Dependencia de Envoy de contenedor de aplicación**
Los contenedores de aplicación en las definiciones de tarea deben esperar a que arranque y comience el proxy de Envoy antes de poder comenzar. Para asegurarse de que esto ocurra, establezca una sección `dependsOn` en cada definición de contenedor de la aplicación para que espere a que el contenedor de Envoy notifique el estado `HEALTHY`. El siguiente código muestra un ejemplo de definición de contenedor de aplicación con esta dependencia. Todas las propiedades del siguiente ejemplo son necesarias. Algunos de los valores de las propiedades también son obligatorios, pero otros sí*replaceable*.
```
{
"name": "appName",
"image": "appImage",
"portMappings": [{
"containerPort": 9080,
"hostPort": 9080,
"protocol": "tcp"
}],
"essential": true,
"dependsOn": [{
"containerName": "envoy",
"condition": "HEALTHY"
}]
}
```
**Definición de contenedor de Envoy**
Las definiciones de tareas de Amazon ECS deben incluir una imagen del contenedor de App Mesh Envoy.
Todas las regiones [compatibles](https://docs.aws.amazon.com/general/latest/gr/appmesh.html) se pueden *Region-code* sustituir por cualquier región que no sea `me-south-1` `ap-east-1``ap-southeast-3`,`eu-south-1`,`il-central-1`, y`af-south-1`.
Standard
```
840364872350.dkr.ecr.region-code.amazonaws.com/aws-appmesh-envoy:v1.34.13.0-prod
```
Cumple con las normas 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
```
Cumple con FIPS
```
public.ecr.aws/appmesh/aws-appmesh-envoy:v1.34.13.0-prod-fips
```
**importante**
Solo se admite el uso de la versión v1.9.0.0-prod o posterior con App Mesh.
Debe usar la imagen del contenedor de App Mesh Envoy hasta que el equipo del proyecto de Envoy fusione los cambios compatibles con App Mesh. [Para obtener más información, consulta el tema de la GitHub hoja de ruta.](https://github.com/aws/aws-app-mesh-roadmap/issues/10)
Todas las propiedades del siguiente ejemplo son necesarias. Algunos de los valores de las propiedades también son obligatorios, pero otros sí. *replaceable*
**nota**
La definición de contenedor de Envoy se debe marcar como `essential`.
Recomendamos asignar unidades de CPU de `512` y al menos `64` MiB de memoria al contenedor de Envoy. En Fargate, el valor más bajo que podrá establecer son `1024` MiB de memoria.
El nombre del nodo virtual del servicio de Amazon ECS debe establecerse en el valor de la propiedad `APPMESH_RESOURCE_ARN`. Esta propiedad requiere la versión `1.15.0` o posterior de la imagen de Envoy. Para obtener más información, consulte [Imagen de Envoy](envoy.md).
El valor de la configuración `user` debe coincidir con el valor `IgnoredUID` de la configuración del proxy de definición de tarea. En este ejemplo, usaremos `1337`.
La comprobación de estado que se muestra aquí espera a que el contenedor de Envoy arranque correctamente antes de notificar a Amazon ECS que el contenedor de Envoy está en buen estado y listo para que se inicien los contenedores de la aplicación.
De forma predeterminada, App Mesh utiliza el nombre del recurso que se especificó en `APPMESH_RESOURCE_ARN` cuando Envoy hace referencia a sí mismo en métricas y registros de seguimiento. Puede anular este comportamiento estableciendo la variable de entorno `APPMESH_RESOURCE_CLUSTER` con su propio nombre. Esta propiedad requiere la versión `1.15.0` o posterior de la imagen de Envoy. Para obtener más información, consulte [Imagen de Envoy](envoy.md).
En el siguiente bloque se muestra un ejemplo de definición de contenedor de 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"
}
```
**Ejemplos de definiciones de tarea**
Las definiciones de tareas de Amazon ECS de ejemplo siguientes muestran cómo combinar los ejemplos de arriba en una definición de tarea para `taskB`. Se proporcionan ejemplos para crear tareas para ambos tipos de lanzamiento de Amazon ECS con o sin uso de AWS X-Ray. Cambie los *replaceable* valores, según proceda, para crear definiciones de tareas para las tareas nombradas `taskBv2` y `taskA` del escenario. Sustituya el nombre de malla y el nombre del nodo virtual por el valor `APPMESH_RESOURCE_ARN` y una lista de los puertos donde la aplicación escucha el valor `AppPorts` de la configuración de proxy. De forma predeterminada, App Mesh utiliza el nombre del recurso que se especificó en `APPMESH_RESOURCE_ARN` cuando Envoy hace referencia a sí mismo en métricas y registros de seguimiento. Puede anular este comportamiento estableciendo la variable de entorno `APPMESH_RESOURCE_CLUSTER` con su propio nombre. Todas las propiedades de los siguientes ejemplos son necesarias. Algunos de los valores de las propiedades también son obligatorios, pero otros sí*replaceable*.
Si está ejecutando una tarea de Amazon ECS como se describe en la sección Credenciales, debe agregar un [rol de IAM de tarea](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html) existente a los ejemplos.
**importante**
Fargate debe usar un valor de puerto superior a 1024.
**Example Definición de tareas de JSON para Amazon ECS: Fargate en contenedores de 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 Definición de tareas de JSON para Amazon ECS con AWS X-Ray contenedores Fargate en Linux**
X-Ray permite recopilar datos sobre las solicitudes que una aplicación sirve y proporciona herramientas que puede utilizar para visualizar el flujo de tráfico. Utilizar el controlador de X-Ray para Envoy permite a Envoy facilitar información de rastreo a X-Ray. Puede habilitar el rastreo de X-Ray mediante la [Configuración de Envoy](https://docs.aws.amazon.com/app-mesh/latest/userguide/envoy.html). En función de la configuración, Envoy envía datos de rastreo al daemon de X-Ray que se ejecuta como un contenedor [sidecar](https://docs.aws.amazon.com/xray/latest/devguide/xray-daemon-ecs.html) y el daemon reenvía los rastreos al servicio de X-Ray. Una vez que los rastreos se publican en X-Ray, puede utilizar la consola de X-Ray para visualizar el gráfico de llamada al servicio y solicitar detalles de rastreo. El siguiente JSON representa una definición de tarea para habilitar la integración de 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 la definición de tarea de Amazon ECS: tipo de lanzamiento de 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 Definición de tareas de JSON para Amazon ECS con AWS X-Ray tipo de lanzamiento 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"
}
```
## Temas avanzados
### Implementaciones de valores controlados mediante App Mesh
Las versiones e implementaciones de valores controlados ayudan a cambiar el tráfico entre una versión antigua de una aplicación y una versión recién implementada. También monitoriza el estado de la versión recién implementada. Si hay algún problema con la nueva versión, la implementación de valores controlados puede devolver automáticamente el tráfico a la versión anterior. Las implementaciones de valores controlados permiten cambiar el tráfico entre versiones de la aplicación con más control.
Para obtener más información sobre cómo aplicar las implementaciones de valores controlados para Amazon ECS mediante App Mesh, consulte [Crear una canalización con las implementaciones de valores controlados para Amazon ECS mediante App Mesh](https://aws.amazon.com/blogs/containers/create-a-pipeline-with-canary-deployments-for-amazon-ecs-using-aws-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).
# 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
```
# Introducción a AWS App Mesh Amazon EC2
**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).
Este tema le ayuda a utilizarlo AWS App Mesh con un servicio real que se ejecuta en Amazon EC2. Este tutorial abarca las características básicas de varios tipos de recursos de App Mesh.
## Escenario
Para ilustrar cómo usar App Mesh, suponga que tiene una aplicación con las siguientes características:
+ Consta de dos servicios denominados `serviceA` y `serviceB`.
+ Ambos servicios están registrados en un espacio de nombres denominado `apps.local`.
+ `ServiceA` se comunica con `serviceB` a través de HTTP/2, puerto 80.
+ Ya ha implementado la versión 2 de `serviceB` y la ha registrado con el nombre `serviceBv2` en el espacio de nombres `apps.local`.
Tiene los siguientes requisitos:
+ Desea enviar el 75 por ciento del tráfico desde `serviceA` `serviceB` y el 25 por ciento del tráfico hacia `serviceBv2` First. Si solo envías el 25 por ciento a`serviceBv2`, puedes validar que está libre de errores antes de enviar el 100 por ciento del tráfico desde allí`serviceA`.
+ Desea poder ajustar fácilmente la proporción del tráfico para que el 100 % del tráfico vaya hacia `serviceBv2` una vez que se demuestre que es de confianza. Una vez que se envía todo el tráfico a `serviceBv2`, desea suspender `serviceB`.
+ No quiere tener que cambiar ningún código de aplicación existente o registro de detección de servicios para que sus servicios reales cumplan los requisitos anteriores.
Para satisfacer sus requisitos, ha decidido crear una malla de servicios de App Mesh con servicios virtuales, nodos virtuales, un enrutador virtual y una ruta. Después de implementar la malla, actualiza los servicios para utilizar el proxy de Envoy. Una vez actualizados, sus servicios se comunican entre sí a través del proxy de Envoy en lugar de directamente.
## Requisitos previos
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. 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.
Si aún no tiene los servicios en ejecución, puede lanzar instancias de Amazon EC2 e implementar aplicaciones en ellas. Para obtener más información, consulte el [tutorial: Introducción a las instancias Linux de Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-lamp-amazon-linux-2.html) en la Guía del usuario de Amazon EC2. 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: Crear una malla y un servicio virtual
Una malla de servicios es un límite lógico para el tráfico de red entre los servicios que residen dentro de ella. Para obtener más información, consulte [Mallas de servicios](meshes.md). Un servicio virtual es una abstracción de un servicio real. Para obtener más información, consulte [Servicios virtuales](virtual_services.md).
Cree los siguientes recursos :
+ Una malla denominada `apps`, ya que todos los servicios del escenario están registrados en el espacio de nombres `apps.local`.
+ Un servicio virtual llamado `serviceb.apps.local`, ya que el servicio virtual representa un servicio que se puede detectar con ese nombre y no desea cambiar el código para hacer referencia a otro nombre. Un servicio virtual llamado `servicea.apps.local` se agrega en un paso posterior.
Puede utilizar la AWS CLI versión 1.18.116 Consola de administración de AWS o superior o la 2.0.38 o superior para completar los siguientes pasos. Si utiliza el AWS CLI, utilice el `aws --version` comando para comprobar la versión instalada. AWS CLI Si no tiene instalada 1.18.116 o posterior o bien la 2.0.38 o posterior, debe [instalar o actualizar la AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/appmesh/cli-chap-install.html). Seleccione la pestaña de la herramienta que desea utilizar.
------
#### [ Consola de administración de AWS ]
1. Abre el asistente de primera ejecución de la consola App Mesh al comenzar [https://console.aws.amazon.com/appmesh/.](https://console.aws.amazon.com/appmesh/get-started)
1. Para **Nombre de malla**, escriba **apps**.
1. En **Nombre del servicio virtual**, escriba **serviceb.apps.local**.
1. Para continuar, elija **Siguiente**.
------
#### [ AWS CLI ]
1. Cree una malla con el comando `[create-mesh](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-mesh.html)`.
```
aws appmesh create-mesh --mesh-name apps
```
1. Cree un servicio virtual con el 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 {}
```
------
## Paso 2: Crear un nodo virtual
Un nodo virtual actúa como un puntero lógico a un servicio real. Para obtener más información, consulte [Nodos virtuales](virtual_nodes.md).
Cree un nodo virtual denominado `serviceB`, ya que uno de los nodos virtuales representa el servicio real denominado `serviceB`. El servicio real que representa el nodo virtual es detectable a través de `DNS` con un nombre de host de `serviceb.apps.local`. También puede detectar servicios reales mediante AWS Cloud Map. El nodo virtual escucha el tráfico utilizando el protocolo HTTP/2 en el puerto 80. También se admiten otros protocolos, así como comprobaciones de estado. Creará nodos virtuales para `serviceA` y `serviceBv2` en un paso posterior.
------
#### [ Consola de administración de AWS ]
1. En **Nombre del nodo virtual**, escriba **serviceB**.
1. En **Método de detección de servicios**, elija **DNS** y escriba **serviceb.apps.local** en **Nombre de host DNS**.
1. En **Configuración del agente de escucha**, elija **http2** en **Protocolo** y escriba **80** en **Puerto**.
1. Para continuar, elija **Siguiente**.
------
#### [ AWS CLI ]
1. Cree un archivo denominado `create-virtual-node-serviceb.json` con el siguiente contenido:
```
{
"meshName": "apps",
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http2"
}
}
],
"serviceDiscovery": {
"dns": {
"hostname": "serviceB.apps.local"
}
}
},
"virtualNodeName": "serviceB"
}
```
1. Cree el nodo virtual con el [create-virtual-node](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-virtual-node.html)comando utilizando el archivo JSON como entrada.
```
aws appmesh create-virtual-node --cli-input-json file://create-virtual-node-serviceb.json
```
------
## Paso 3: Crear un enrutador virtual y una ruta
Los routers virtuales enrutan el tráfico de uno o más servicios virtuales dentro de la malla. Para obtener más información, consulte [Enrutadores virtuales](virtual_routers.md) y [Rutas](routes.md).
Cree los siguientes recursos :
+ Un enrutador virtual llamado `serviceB`, ya que el servicio virtual `serviceB.apps.local` no inicia la comunicación saliente con ningún otro servicio. Recuerde que el servicio virtual que creó anteriormente es una abstracción de su servicio `serviceb.apps.local` real. El servicio virtual envía tráfico al router virtual. El enrutador virtual escucha el tráfico utilizando el protocolo HTTP/2 en el puerto 80. También se admiten otros protocolos.
+ Una ruta llamada `serviceB`. Enruta el cien por cien de su tráfico al nodo virtual `serviceB`. La ponderación se realiza en un paso posterior una vez que haya añadido el nodo virtual `serviceBv2`. Aunque no se incluye en esta guía, puede agregar criterios de filtro adicionales para la ruta y agregar una política de reintento para que el proxy de Envoy realice varios intentos de enviar tráfico a un nodo virtual cuando experimenta un problema de comunicación.
------
#### [ Consola de administración de AWS ]
1. En **Nombre del enrutador virtual**, escriba **serviceB**.
1. En **Configuración del agente de escucha**, elija **http2** en **Protocolo** y especifique **80** en **Puerto**.
1. En **Nombre de ruta**, escriba **serviceB**.
1. En **Tipo de ruta**, elija **http2**.
1. En **Nombre de nodo virtual**, en **Configuración de destino**, seleccione `serviceB` y escriba **100** para **Ponderación**.
1. En **Configuración de coincidencia**, elija un **Método**.
1. Para continuar, elija **Siguiente**.
------
#### [ AWS CLI ]
1. Cree un router virtual.
1. Cree un archivo denominado `create-virtual-router.json` con el siguiente contenido:
```
{
"meshName": "apps",
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http2"
}
}
]
},
"virtualRouterName": "serviceB"
}
```
1. Cree el router virtual con el [create-virtual-router](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-virtual-router.html)comando utilizando el archivo JSON como entrada.
```
aws appmesh create-virtual-router --cli-input-json file://create-virtual-router.json
```
1. Cree una ruta.
1. Cree un archivo denominado `create-route.json` con el siguiente contenido:
```
{
"meshName" : "apps",
"routeName" : "serviceB",
"spec" : {
"httpRoute" : {
"action" : {
"weightedTargets" : [
{
"virtualNode" : "serviceB",
"weight" : 100
}
]
},
"match" : {
"prefix" : "/"
}
}
},
"virtualRouterName" : "serviceB"
}
```
1. Cree la ruta con el comando [create-route](https://docs.aws.amazon.com/cli/latest/reference/appmesh/create-route.html) utilizando el archivo JSON como entrada.
```
aws appmesh create-route --cli-input-json file://create-route.json
```
------
## Paso 4: Revisar y crear
Revise la configuración comparándola con las instrucciones anteriores.
------
#### [ Consola de administración de AWS ]
Elija **Editar** si necesita realizar cambios en cualquier sección. Una vez esté satisfecho con la configuración, elija **Crear malla**.
La pantalla **Estado** muestra todos los recursos de malla que se han creado. Puede ver los recursos creados en la consola seleccionando **Ver malla**.
------
#### [ AWS CLI ]
Revise la configuración de la malla que creó con el comando [describe-mesh](https://docs.aws.amazon.com/cli/latest/reference/appmesh/describe-mesh.html).
```
aws appmesh describe-mesh --mesh-name apps
```
Revise la configuración del servicio virtual que creó con el [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 la configuración del nodo virtual que creó con el [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 la configuración del router virtual que creó con el [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 la configuración de la ruta que creó con el 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
```
------
## Paso 5: Crear recursos adicionales
Para completar el escenario, debe:
+ Crear un nodo virtual denominado `serviceBv2` y otro denominado `serviceA`. Ambos nodos virtuales escuchan las solicitudes a través del puerto HTTP/2 80. Para el nodo virtual `serviceA`, configure un backend de `serviceb.apps.local`. Todo el tráfico saliente del nodo virtual `serviceA` se envía al servicio virtual denominado `serviceb.apps.local`. Aunque no se trata en esta guía, también puede especificar una ruta de acceso de archivo en la que escribir registros de acceso para un nodo virtual.
+ Cree un servicio virtual adicional llamado `servicea.apps.local`, que envíe todo el tráfico directamente al nodo virtual `serviceA`.
+ Actualizar la ruta de `serviceB` que creó en un paso anterior para enviar el 75 % de su tráfico al nodo virtual `serviceB` y el 25 % de su tráfico al nodo virtual `serviceBv2`. Con el tiempo, puede continuar modificando las proporciones hasta que `serviceBv2` reciba el 100 % del tráfico. Una vez que se envíe todo el tráfico hacia `serviceBv2`, puede cerrar y suspender el nodo virtual `serviceB` y el servicio real. Cuando cambia las ponderaciones, el código no requiere ninguna modificación, ya que los nombres del servicio real y virtual `serviceb.apps.local` no cambian. Recuerde que el servicio virtual `serviceb.apps.local` envía tráfico al router virtual, que enruta el tráfico a los nodos virtuales. Los nombres de detección de servicios para los nodos virtuales se pueden cambiar en cualquier momento.
------
#### [ Consola de administración de AWS ]
1. En el panel de navegación izquierdo, seleccione **Mallas**.
1. Seleccione la malla `apps` que creó en un paso anterior.
1. En el panel de navegación izquierdo, seleccione **Nodos virtuales**.
1. Elija **Crear nodo virtual**.
1. En **Nombre del nodo virtual**, escriba **serviceBv2**, en **Método de detección de servicios**, elija **DNS**, y en **Nombre de host DNS** escriba **servicebv2.apps.local**.
1. En **Configuración del agente de escucha**, seleccione **http2** para **Protocolo** y escriba **80** para **Puerto**.
1. Elija **Crear nodo virtual**.
1. Elija de nuevo **Crear nodo virtual**. Escriba **serviceA** en el **Nombre del nodo virtual**. En **Método de detección de servicios**, elija **DNS** y en **Nombre de host DNS**, escriba **servicea.apps.local**.
1. En **Escriba un nombre de servicio virtual**, en **Nuevo backend**, escriba **serviceb.apps.local**.
1. En **Configuración del agente de escucha**, elija **http2** para **Protocolo**, escriba **80** para **Puerto** y, a continuación, elija **Crear nodo virtual**.
1. En el panel de navegación izquierdo, seleccione** Routers virtuales** y, a continuación, seleccione el router virtual `serviceB` de la lista.
1. En **Rutas**, seleccione la ruta llamada `ServiceB` que creó en un paso anterior y elija **Editar**.
1. En **Destinos**, **Nombre del nodo virtual**, cambie el valor de **Ponderación** de `serviceB` a **75**.
1. Elija **Agregar objetivo**, elija `serviceBv2` en la lista desplegable y establezca el valor de **Ponderación** en **25**.
1. Seleccione **Save**.
1. En el panel de navegación izquierdo, seleccione** Servicios virtuales** y, a continuación, elija **Crear servicio virtual**.
1. Escriba **servicea.apps.local** en **Nombre del servicio virtual**, seleccione **Nodo virtual** en **Proveedor**, seleccione `serviceA` en **Nodo virtual** y, a continuación, elija **Crear servicio virtual.**
------
#### [ AWS CLI ]
1. Cree el nodo virtual `serviceBv2`.
1. Cree un archivo denominado `create-virtual-node-servicebv2.json` con el siguiente contenido:
```
{
"meshName": "apps",
"spec": {
"listeners": [
{
"portMapping": {
"port": 80,
"protocol": "http2"
}
}
],
"serviceDiscovery": {
"dns": {
"hostname": "serviceBv2.apps.local"
}
}
},
"virtualNodeName": "serviceBv2"
}
```
1. Cree el nodo virtual.
```
aws appmesh create-virtual-node --cli-input-json file://create-virtual-node-servicebv2.json
```
1. Cree el nodo virtual `serviceA`.
1. Cree un archivo denominado `create-virtual-node-servicea.json` con el siguiente contenido:
```
{
"meshName" : "apps",
"spec" : {
"backends" : [
{
"virtualService" : {
"virtualServiceName" : "serviceb.apps.local"
}
}
],
"listeners" : [
{
"portMapping" : {
"port" : 80,
"protocol" : "http2"
}
}
],
"serviceDiscovery" : {
"dns" : {
"hostname" : "servicea.apps.local"
}
}
},
"virtualNodeName" : "serviceA"
}
```
1. Cree el nodo virtual.
```
aws appmesh create-virtual-node --cli-input-json file://create-virtual-node-servicea.json
```
1. Actualice el servicio virtual `serviceb.apps.local` que creó en un paso anterior para enviar su tráfico al router virtual `serviceB`. Cuando el servicio virtual se creó originalmente, no envió tráfico a ninguna parte, ya que el router virtual `serviceB` aún no se había creado.
1. Cree un archivo denominado `update-virtual-service.json` con el siguiente contenido:
```
{
"meshName" : "apps",
"spec" : {
"provider" : {
"virtualRouter" : {
"virtualRouterName" : "serviceB"
}
}
},
"virtualServiceName" : "serviceb.apps.local"
}
```
1. Actualice el servicio virtual con el [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. Actualice la ruta `serviceB` que creó en un paso anterior.
1. Cree un archivo denominado `update-route.json` con el siguiente contenido:
```
{
"meshName" : "apps",
"routeName" : "serviceB",
"spec" : {
"http2Route" : {
"action" : {
"weightedTargets" : [
{
"virtualNode" : "serviceB",
"weight" : 75
},
{
"virtualNode" : "serviceBv2",
"weight" : 25
}
]
},
"match" : {
"prefix" : "/"
}
}
},
"virtualRouterName" : "serviceB"
}
```
1. Actualice la ruta con el 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. Cree el servicio virtual `serviceA`.
1. Cree un archivo denominado `create-virtual-servicea.json` con el siguiente contenido:
```
{
"meshName" : "apps",
"spec" : {
"provider" : {
"virtualNode" : {
"virtualNodeName" : "serviceA"
}
}
},
"virtualServiceName" : "servicea.apps.local"
}
```
1. Cree el servicio virtual.
```
aws appmesh create-virtual-service --cli-input-json file://create-virtual-servicea.json
```
------
**Resumen de malla**
Antes de crear la malla de servicio, tenía tres servicios reales denominados `servicea.apps.local`, `serviceb.apps.local` y `servicebv2.apps.local`. Además de los servicios reales, ahora tiene una malla de servicio que contiene los siguientes recursos que representan los servicios reales:
+ Dos servicios virtuales. El proxy envía todo el tráfico desde el servicio virtual `servicea.apps.local` al servicio virtual `serviceb.apps.local` a través de un router virtual.
+ Tres nodos virtuales denominados `serviceA`, `serviceB` y `serviceBv2`. El proxy de Envoy utiliza la información de detección de servicios configurada para los nodos virtuales para buscar las direcciones IP de los servicios reales.
+ Un router virtual con una ruta que indica al proxy de Envoy que enrute el 75 % del tráfico entrante al nodo virtual `serviceB` y el 25 % del tráfico al nodo virtual `serviceBv2`.
## Paso 6: Actualizar los servicios
Después de crear su malla, debe realizar las siguientes tareas:
+ Autorice al proxy de Envoy a que implemente con cada servicio para leer la configuración de uno o más nodos virtuales. Para obtener más información acerca de cómo autorizar el proxy, consulte [Autorización de proxy de Envoy](proxy-authorization.md).
+ Para actualizar el servicio existente, siga los pasos que se indican a continuación.
**Para configurar una instancia de Amazon EC2 como miembro del nodo virtual**
1. Crear un rol de IAM.
1. Cree un archivo denominado `ec2-trust-relationship.json` con el siguiente contenido.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "ec2.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Cree un rol de IAM con el siguiente comando.
```
aws iam create-role --role-name mesh-virtual-node-service-b --assume-role-policy-document file://ec2-trust-relationship.json
```
1. Asocie políticas de IAM al rol que le permite leer de Amazon ECR y solo la configuración de un nodo virtual de App Mesh específico.
1. Cree un archivo llamado `virtual-node-policy.json` con el siguiente contenido. `apps` es el nombre de la malla que creó en [Paso 1: Crear una malla y un servicio virtual](#create-mesh-and-virtual-service) y `serviceB` es el nombre del nodo virtual que creó en [Paso 2: Crear un nodo virtual](#create-virtual-node). *111122223333*Sustitúyalo por el ID de tu cuenta y *us-west-2* por la región en la que creaste la conexión.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "appmesh:StreamAggregatedResources",
"Resource": [
"arn:aws:appmesh:us-west-2:111122223333:mesh/apps/virtualNode/serviceB"
]
}
]
}
```
------
1. Cree la política mediante el siguiente comando.
```
aws iam create-policy --policy-name virtual-node-policy --policy-document file://virtual-node-policy.json
```
1. Asocie la política que ha creado en el anterior paso al rol, para que este solo pueda leer la configuración del nodo virtual `serviceB` desde 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. Asocie la política administrada `AmazonEC2ContainerRegistryReadOnly` al rol para que pueda extraer la imagen del contenedor de Envoy de Amazon ECR.
```
aws iam attach-role-policy --policy-arn arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryReadOnly --role-name mesh-virtual-node-service-b
```
1. [Lance una instancia de Amazon EC2 con el rol de IAM](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#launch-instance-with-role) que ha creado.
1. Conéctese a la instancia mediante SSH.
1. Instala Docker y el AWS CLI en tu instancia de acuerdo con la documentación del sistema operativo.
1. Autentíquese en el repositorio de Amazon ECR de Envoy en la región de la que desee que el cliente de Docker extraiga la imagen:
+ Todas las regiones excepto `me-south-1`, `ap-east-1`, `ap-southeast-3`, `eu-south-1`, `il-central-1` y `af-south-1`. Puedes *us-west-2* sustituirlo por cualquier [región compatible](https://docs.aws.amazon.com/general/latest/gr/appmesh.html)`me-south-1`, excepto`ap-east-1`,`ap-southeast-3`, `eu-south-1``il-central-1`, y`af-south-1`.
```
$aws ecr get-login-password \
--region us-west-2 \
| docker login \
--username AWS \
--password-stdin 840364872350.dkr.ecr.us-west-2.amazonaws.com
```
+ Región de `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ón de `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. Ejecute uno de los siguientes comandos para iniciar el contenedor de App Mesh Envoy en la instancia, en función de la región de la que desee extraer la imagen. *serviceB*Los valores *apps* y son los nombres de malla y nodo virtual definidos en el escenario. Esta información indica al proxy qué configuración del nodo virtual debe leer en App Mesh. Para completar el escenario, también debe completar estos pasos para las instancias de Amazon EC2 que alojan los servicios representados por los nodos virtuales `serviceBv2` y `serviceA`. Para su propia aplicación, reemplace estos valores con los suyos propios.
+ Todas las regiones excepto `me-south-1`, `ap-east-1`, `ap-southeast-3`, `eu-south-1`, `il-central-1` y `af-south-1`. Puede *Region-code* sustituirlo por cualquier [región compatible](https://docs.aws.amazon.com/general/latest/gr/appmesh.html)`me-south-1`, excepto las `af-south-1` regiones `ap-east-1` `ap-southeast-3``eu-south-1`,`il-central-1`,, y. Puede reemplazar `1337` con cualquier valor entre `0` y `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ón `me-south-1`. Puede reemplazar `1337` con cualquier valor entre `0` y `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ón `ap-east-1`. Puede reemplazar `1337` con cualquier valor entre `0` y `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**
La propiedad `APPMESH_RESOURCE_ARN` requiere una versión `1.15.0` o posterior de la imagen de Envoy. Para obtener más información, consulte [Imagen de Envoy](envoy.md).
**importante**
Solo se admite el uso de la versión v1.9.0.0-prod o posterior con App Mesh.
1. Seleccione `Show more` a continuación. Cree un archivo llamado `envoy-networking.sh` en la instancia con el siguiente contenido. *8000*Sustitúyalo por el puerto que utiliza el código de la aplicación para el tráfico entrante. Puede cambiar el valor de `APPMESH_IGNORE_UID`, pero el valor debe ser el mismo que el que ha especificado en el paso anterior, por ejemplo `1337`. Puede añadir direcciones adicionales a `APPMESH_EGRESS_IGNORED_IP` si es necesario. No modifique ninguna otra línea.
```
#!/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 reglas de `iptables` para enrutar el tráfico de la aplicación al proxy Envoy, ejecute el script que ha creado en el paso anterior.
```
sudo ./envoy-networking.sh
```
1. Inicie el código de aplicación del nodo virtual.
**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).
# Ejemplos de App Mesh
**importante**
Aviso de fin de soporte: el 30 de septiembre de 2026, AWS suspenderemos el 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).
AWS App Mesh En el siguiente end-to-end repositorio encontrará tutoriales que muestran cómo actuar y ejemplos de código para la integración con varios AWS servicios:
[Ejemplos de App Mesh](https://github.com/aws/aws-app-mesh-examples)