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 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).