Hacer uso de App Mesh con Amazon EKS en un entorno Multi-Cuenta

Por Guilherme França y Bruno Emer, Solutions Architects, Amazon Web Services

Hoy en día, muchos clientes están adoptando microservicios para ser capaces de desarrollar software más rápidamente, permitiendo una mayor agilidad e innovación y acelerando el time-to-market de nuevas funcionalidades y productos. La adopción de una arquitectura basada en microservicios se centra en la implementación de aplicaciones pequeñas independientes, que abordan necesidades de negocio específicas y se comunican a través de APIs bien definidas. Para implementar este modelo de desarrollo, las empresas están cambiando la forma en que despliegan sus servicios y adoptando una estrategia diferente, que hace uso de varias cuentas de AWS para ejecutar sus cargas de trabajo. Este enfoque minimiza el riesgo de tener un único entorno compartido entre múltiples aplicaciones de diferentes equipos y/o unidades de negocio, pero requiere de una capa de comunicación que permita que los recursos desplegados en las distintas cuentas se puedan comunicar entre sí.

Es importante enfatizar, que la comunicación a través de la red no es la única área a considerar para implementar un entorno basado en microservicios. Es muy probable que surjan nuevas tareas que consuman tiempo y potencialmente ralenticen todo el proceso de innovación (principalmente en la configuración y el gobierno de la nube) y servicios como AWS Organizations y AWS Control Tower pueden ayudar a facilitar la configuración y el gobierno de los entornos multi-cuenta en AWS.

Al implementar microservicios, es muy importante tener el control de las comunicaciones. En una configuración multi-cuenta, es necesario tener visibilidad y hacer cumplir las políticas de red pre-definidas entre las aplicaciones que se ejecuten en el entorno. Aquí es donde AWS App Mesh es importante.

AWS App Mesh es una malla de servicios que proporciona la administración de la red a nivel de la aplicación para facilitar la comunicación entre sus servicios, no solo en varios tipos de infraestructura, sino también a través de diferentes cuentas de AWS. App Mesh estandariza la forma en que se comunican los servicios, ofreciendo visibilidad de un extremo a otro y asegurando una alta disponibilidad para las aplicaciones. Tener una malla entre múltiples cuentas, aumenta la fiabilidad y seguridad de la comunicación de los distintos servicios, utilizando características como mutual TLS (mTLS), reintento de conexión y manejo del tiempo de espera, sin necesidad de realizar cambios en el aplicativo. Esto ayuda a reducir la complejidad del código.

Tutorial

En este artículo, mostraremos cómo podemos aprovechar las capacidades de AWS App Mesh para integrar diferentes componentes de una aplicación que se ejecuta en diferentes clústers de EKS desplegados en cuentas de AWS separadas.

Esto se puede aplicar tanto si estamos creando el entorno completamente desde cero (como mostramos a continuación) o si ya tiene diferentes clústers de EKS ejecutándose en un entorno multi-cuenta y necesita implementar una malla de servicios a través de ellos. Si éste es su caso, donde ya tiene la infraestructura aprovisionada, puede saltar directamente al paso 3 – Instalar los componentes de App Mesh.

Usaremos dos clústers de EKS, cada uno en su propia cuenta de AWS y permitiremos la conectividad entre los dos clústers a través de una conexión VPC Peering . Este enfoque nos permite mantener los entornos separados, mientras se brinda conectividad entre ambos. Además de implementar conectividad a través de la conexión VPC peering, usaremos AWS Resource Access Manager (AWS RAM) para compartir la malla de servicio entre cuentas y así que sea visible en ambos clústers de EKS.

En este tutorial, crearemos los distintos componentes de AWS App Mesh y los desplegaremos haciendo uso de una aplicación de muestra llamada Yelb. Yelb permite a los usuarios votar sobre un conjunto de opciones, como restaurantes, y actualiza dinámicamente los gráficos en función de los votos recibidos. Además, Yelb realiza un seguimiento del número de páginas vistas e imprime el nombre del host de la instancia yelb-appserver que atiende la solicitud API tras una votación o un refresco de la página. Los componentes de Yelb incluyen:

Una interfaz, como parte del frontend, llamada yelb-ui responsable de proporcionar el código JS al navegador.
Un servidor de aplicaciones llamado yelb-appserver, una aplicación Sinatra que lee y escribe en un servidor de caché (redis-server) y una base de datos Postgres en el backend (yelb-db).
Redis almacena el número de páginas vistas y Postgres almacena los votos.

La siguiente imagen muestra nuestra arquitectura.

Hay dos clústers EKS, cada uno en su cuenta AWS y VPC y una malla de servicio que abarca ambas cuentas. El componente yelb-ui se desplegará en el Clúster 1 en la cuenta Frontend y en el Clúster 2 de la cuenta Backend, el servidor de aplicaciones yelb-appserver, el servidor de cache redis y base de datos postgres . El objetivo es tener una sola malla entre ambas cuentas de AWS.

Tenga en cuenta que en esta implementación, no estamos desplegando ningún balanceador de carga para manejar la comunicación entre los servicios de Yelb. En su lugar, aprovecharemos las capacidades de balanceo de tráfico a nivel de cliente proporcionadas por App Mesh. Con ello, permitimos que la aplicación cliente se conecte directamente a una instancia del servicio, lo que elimina un salto adicional. Los clientes descubren servicios consultando un registro que mantiene una lista de instancias activas por cada uno de los servicios junto con sus detalles correspondientes de conexión, como direcciones IP, nombres de host y puertos. Estas capacidades de descubrimiento de servicios serán proporcionadas por la integración entre AWS App Mesh y AWS Cloud Map .

1. Configurar la infraestructura:

Para seguir adelante, necesitaremos contar con un entorno con algunas herramientas. Podemos hacer uso de una instancia de AWS Cloud9 para llevar a cabo este tutorial. Si desea crear una instancia de Cloud9 en su cuenta, siga los pasos descritos en el taller de EKS, secciones desde Create a Workspace a Update IAM Settings for your Workspace.

Estas son las herramientas que necesitaremos tener instaladas:

La última versión de AWS CLI
Docker
Git
jq
Helm
eksctl
kubectl

Dado que ejecutaremos esto en dos cuentas diferentes, debe asegurarse de tener perfiles con credenciales para ambas cuentas, configurando los archivos ~/.aws/credentials y ~/.aws/config. Por ejemplo:

cat ~/.aws/credentials

[frontend]
aws_access_key_id = ...
aws_secret_access_key = ...
[backend]
aws_access_key_id = ...
aws_secret_access_key = ...

cat ~/.aws/config

[profile frontend]
region = us-west-2
[profile backend]
region = us-west-2

Puede obtener más información sobre la creación de archivos de configuración en la guía del usuario de AWS CLI .

Después de instalar todo y configurar los perfiles, procedamos a clonar el repositorio de GitHub que tiene los scripts que usaremos en este tutorial:

git clone https://github.com/aws/aws-app-mesh-examples.git
cd aws-app-mesh-examples/walkthroughs/eks-app-mesh-multi-account/

Usaremos plantillas de CloudFormation para crear la VPC, los grupos de seguridad, las tablas de enrutamiento y la conexión de VPC peering entre las dos cuentas; si desea echar un vistazo, éstas se encuentran ubicadas en el directorio infrastructure del repositorio que acabamos de clonar. Puede crearlos ejecutando el siguiente script:

./infrastructure/setup.sh

Ahora que tenemos la infraestructura configurada, es hora de crear nuestros clústers de EKS.

2. Crear los clústers de EKS

En este paso, usaremos la herramienta eksctl para crear los clústers de EKS en las cuentas Frontend y Backend, ejecutando el siguiente script:

./eks/setup.sh

Puede ver sus nuevos clústers ejecutando kubectl.

kubectl config get-contexts

3. Instalar los componentes de App Mesh

Antes de crear los recursos de la malla y desplegar la aplicación Yelb en los clústers, debe instalar el controlador de AWS App Mesh. Este controlador permite configurar los recursos de App Mesh usando kubectl. Utilizaremos Helm para instalar el controlador App Mesh.

Primero, instale el controlador en el clúster de la cuenta Frontend .

kubectl config use-context <iam_user>@am-multi-account-1.<region>.eksctl.io
helm repo add eks https://aws.github.io/eks-charts
kubectl create ns appmesh-system
helm upgrade -i appmesh-controller eks/appmesh-controller \
--namespace appmesh-system

Ahora, instale el controlador en el clúster de la cuenta Backend .

kubectl config use-context <iam_user>@am-multi-account-2.<region>.eksctl.io
kubectl create ns appmesh-system
helm upgrade -i appmesh-controller eks/appmesh-controller \
--namespace appmesh-system

Confirme que el controlador App Mesh se está ejecutando:

kubectl --context=<iam_user>@am-multi-account-1.<region>.eksctl.io get pods -n appmesh-system
kubectl --context=<iam_user>@am-multi-account-2.<region>.eksctl.io get pods -n appmesh-system

Debería ver un resultado similar a este:

NAME                                READY STATUS   RESTARTS AGE 
appmesh-controller-66b749c78b-67n68 1/1   Running  0        6s

4 – Desplegar y compartir la malla

Ahora que tenemos el controlador de App Mesh configurado en ambos clústers, queremos crear la malla y compartirla con la cuenta Backend .

Primero, creamos el namespace donde se desplegarán los componentes de la malla y la aplicación Yelb en el clúster de la cuenta Frontend .

kubectl config use-context <iam_user>@am-multi-account-1.<region>.eksctl.io
kubectl create ns yelb

Necesitamos agregar dos etiquetas al namespace yelb: mesh y appmesh.k8s.aws/sidecarInjectorWebhook. Estas etiquetas indican al controlador que inyecte y configure los proxies Envoy en los pods:

kubectl label namespace yelb mesh=am-multi-account-mesh
kubectl label namespace yelb "appmesh.k8s.aws/sidecarInjectorWebhook"=enabled

Vamos a crear y compartir la malla con la cuenta Backend :

./mesh/create_mesh.sh

Procedamos a compartir la malla a través de AWS Resource Access Manager:

aws --profile frontend cloudformation deploy \
--template-file shared_resources/shared_mesh.yaml \
--parameter-overrides \
"BackendAccountId=$(aws --profile backend sts get-caller-identity | jq -r .Account)" \
--stack-name am-multi-account-shared-mesh \
--capabilities CAPABILITY_IAM

Ahora, acepte la invitación para compartir recursos en la cuenta Backend.

Ejecute los siguientes comandos para aceptar la invitación:

RESOURCE_SHARE_ARN=$(aws --profile backend ram get-resource-share-invitations \
| jq -r '.resourceShareInvitations[] | select(.resourceShareName=="mesh-share") | .resourceShareInvitationArn')

aws --profile backend ram accept-resource-share-invitation \
--resource-share-invitation-arn $RESOURCE_SHARE_ARN

La cuenta Backend necesita un rol de servicio para que App Mesh pueda descubrir la dirección IP del VirtualNode yelb-appserver usando AWS Cloud Map, créelo como se indica a continuación:

aws --profile backend iam create-service-linked-role \
--aws-service-name appmesh.amazonaws.com (http://appmesh.amazonaws.com/)

5 – Desplegar los recursos de la malla y la aplicación

Dado que los recursos de la cuenta Backend son dependencias de los recursos de la cuenta Frontend , comencemos por crearlos:

Cambie al contexto del clúster de la cuenta Backend :

kubectl config use-context <iam_user>@am-multi-account-2.<region>.eksctl.io

Aunque la malla ya está creada y compartida, el controlador de la malla de la aplicación en el clúster de la cuenta Backend necesita ser consciente de ello, para ello ejecutamos la siguiente secuencia de comandos:

kubectl create ns yelb
kubectl label namespace yelb mesh=am-multi-account-mesh
kubectl label namespace yelb "appmesh.k8s.aws/sidecarInjectorWebhook"=enabled
./mesh/create_mesh.sh

Ahora, procedemos a crear los componentes de malla de servicio en la cuenta Backend , esto creará VirtualNodes, VirtualServices y VirtualRoutes para yelb-appserver, yelb-db y yelb-redis.

kubectl apply -f mesh/yelb-redis.yaml
kubectl apply -f mesh/yelb-db.yaml
kubectl apply -f mesh/yelb-appserver.yaml

Despliega los componentes yelb-appserver, yelb-db y yelb-redis.

kubectl apply -f yelb/resources_backend.yaml

Obtenga el ARN del VirtualService yelb-appserver y cambie la configuración del backend editando el archivo mesh/yelb-ui.yaml.
Este es un proceso manual, la creación del VirtualNode yelb-ui fallará si se omite.

kubectl -n yelb get virtualservice yelb-appserver

# Replace <yelb-appserver virtualServiceARN>
# in mesh/yelb-ui.yaml with the ARN from the 
# command above using your editor of choice

Ahora que tiene todos los componentes de la cuenta Backend desplegados, cambie al clúster de la cuenta Frontend con el siguiente comando:

kubectl config use-context <iam_user>@am-multi-account-1.<region>.eksctl.io

Cree los componentes de la malla de servicio en la cuenta Frontend , esto creará un VirtualNode, VirtualService y un VirtualRoute para yelb-ui.

kubectl apply -f mesh/yelb-ui.yaml

Despliegue el componente yelb-ui.

kubectl apply -f yelb/resources_frontend.yaml

Obtenga la URL de Load Balancer para probar la aplicación desde su navegador:

kubectl get service yelb-ui -n yelb

Debería ver la aplicación como se muestra a continuación, ¡adelante y pruébela!

A través de la consola de AWS , observe que App Mesh se integra sin problemas en la arquitectura multi-cuenta mediante AWS Resource Access Manager y los propietarios de los Virtual Services, Routers y Nodes pueden identificarse fácilmente:

6. Limpieza

Para eliminar todos los recursos creados durante la ejecución de este tutorial, ejecute el script de limpieza con el siguiente comando:

./cleanup.sh

Tenga en cuenta, que este script de limpieza no eliminará ninguna cuenta AWS creada para este tutorial, sino los recursos aprovisionados en ellas durante los pasos anteriores.

Resumen

En este artículo, creamos dos clústers de EKS (cada uno en su propia cuenta y VPC) con un servicio de frontend en uno de los clústers y los recursos de backend en el otro. Usamos una malla de servicio que abarcó ambos clústers, lo que nos permitió simplificar la comunicación entre esos servicios y, al mismo tiempo, brindarnos la posibilidad de agregar funciones como mTLS, reintento de conexión y manejo del tiempo de espera sin cambiar el código de la aplicación. Con este enfoque, los clientes que confían en estrategias con múltiples clústers en un entorno multi-cuenta, pueden comenzar a administrar la conectividad entre estos entornos de una mejor manera y aprovechar todos los beneficios que brinda una malla de servicios.

Tenga en cuenta que la integración en un entorno multi-cuenta es solo una de las características de App Mesh. Puede usar App Mesh para realizar implementaciones canary , implementar pipelines de CI / CD , trazabilidad distribuida , cifrado de tráfico entre servicios y más . Si desea aprender más de sobre AWS App Mesh, también puede acceder al taller práctico de AWS App Mesh .

Si está interesado en probar las nuevas funciones de App Mesh, regístrese en App Mesh Preview Channel . Nos encantaría escuchar sus comentarios.

Blog de Amazon Web Services (AWS)