Simplifique la implementación de aplicaciones multiusuario de Amazon EKS mediante Flux - Recomendaciones de AWS

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.

Simplifique la implementación de aplicaciones multiusuario de Amazon EKS mediante Flux

Creado por Nadeem Rahaman (AWS), Aditya Ambati (AWS), Aniket Dekate (AWS) y Shrikant Patil (AWS)

Repositorio de código: aws-eks-multitenancy-deployment

Entorno: PoC o piloto

Tecnologías: DevOps contenedores y microservicios

Servicios de AWS: AWS CodeBuild; AWS CodeCommit CodePipeline; Amazon EKS; Amazon VPC

Resumen

Muchas empresas que ofrecen productos y servicios son sectores regulados por los datos que deben mantener las barreras de datos entre sus funciones empresariales internas. Este patrón describe cómo puede utilizar la función de tenencia múltiple de Amazon Elastic Kubernetes Service (Amazon EKS) para crear una plataforma de datos que logre el aislamiento lógico y físico entre los inquilinos o usuarios que comparten un único clúster de Amazon EKS. El patrón proporciona aislamiento mediante los siguientes enfoques:

  • Aislamiento del espacio de nombres de Kubernetes

  • Control de acceso basado en roles (RBAC)

  • Políticas de red

  • Cuotas de recursos

  • AWS Identity and Access Management Funciones (IAM) para cuentas de servicio (IRSA)

Además, esta solución utiliza Flux para mantener inmutable la configuración del inquilino al implementar aplicaciones. Puede implementar sus aplicaciones arrendatarias especificando el repositorio arrendatario que contiene el kustomization.yaml archivo Flux en su configuración.

Este patrón implementa lo siguiente:

  • Un AWS CodeCommit repositorio, AWS CodeBuild proyectos y una AWS CodePipeline canalización, que se crean mediante la implementación manual de los scripts de Terraform.

  • Componentes de red y cómputo necesarios para alojar a los inquilinos. Estos se crean a través de Terraform CodePipeline y CodeBuild utilizando Terraform.

  • Espacios de nombres de inquilinos, políticas de red y cuotas de recursos, que se configuran mediante un diagrama de Helm.

  • Aplicaciones que pertenecen a diferentes inquilinos, implementadas mediante Flux.

Le recomendamos que planifique y construya cuidadosamente su propia arquitectura para múltiples inquilinos en función de sus requisitos únicos y sus consideraciones de seguridad. Este patrón proporciona un punto de partida para la implementación.

Requisitos previos y limitaciones

Requisitos previos 

Limitaciones

  • Dependencia de las implementaciones manuales de Terraform: la configuración inicial del flujo de trabajo, que incluye la creación de CodeCommit repositorios, CodeBuild proyectos y CodePipeline canalizaciones, se basa en las implementaciones manuales de Terraform. Esto introduce una posible limitación en términos de automatización y escalabilidad, ya que requiere una intervención manual para los cambios en la infraestructura.

  • CodeCommit dependencia de los repositorios: el flujo de trabajo se basa en CodeCommit los repositorios como solución de gestión del código fuente y está estrechamente AWS vinculado a los servicios.

Arquitectura

Arquitecturas de destino

Este patrón implementa tres módulos para crear la infraestructura de canalización, red e informática de una plataforma de datos, como se ilustra en los siguientes diagramas.

Arquitectura de canalización:

Infraestructura de canalización para la arquitectura multiusuario Amazon EKS

Arquitectura de red:

Infraestructura de red para la arquitectura multiusuario Amazon EKS

Arquitectura de cómputo:

Infraestructura informática para la arquitectura multiusuario Amazon EKS

Herramientas

Servicios de AWS

  • AWS CodeBuildes un servicio de compilación totalmente gestionado que le ayuda a compilar el código fuente, ejecutar pruebas unitarias y producir artefactos listos para su implementación.

  • AWS CodeCommites un servicio de control de versiones que te ayuda a almacenar y gestionar de forma privada los repositorios de Git, sin necesidad de gestionar tu propio sistema de control de código fuente.

  • AWS CodePipelinete ayuda a modelar y configurar rápidamente las diferentes etapas de una versión de software y a automatizar los pasos necesarios para publicar cambios de software de forma continua.

  • Amazon Elastic Kubernetes Service (Amazon EKS) le ayuda a ejecutar AWS Kubernetes sin necesidad de instalar ni mantener su propio plano de control o nodos de Kubernetes.

  • AWS Transit Gateway es un núcleo central que conecta las nubes privadas virtuales (VPC) y las redes en las instalaciones.

  • Amazon Virtual Private Cloud (Amazon VPC) le ayuda a lanzar AWS recursos en una red virtual que haya definido. Esa red virtual es similar a la red tradicional que utiliza en su propio centro de datos, con los beneficios de usar la infraestructura escalable de AWS.

Otras herramientas

  • Las políticas de red de Cilium son compatibles con las políticas de red L3 y L4 de Kubernetes. Se pueden ampliar con políticas L7 para proporcionar seguridad a nivel de API para HTTP, Kafka y gRPC, y otros protocolos similares.

  • Flux es una herramienta de entrega continua (CD) basada en Git que automatiza las implementaciones de aplicaciones en Kubernetes.

  • Helm es un administrador de paquetes de código abierto para Kubernetes que le ayuda a instalar y administrar aplicaciones en su clúster de Kubernetes.

  • Terraform es una herramienta de infraestructura como código (IaC) HashiCorp que le ayuda a crear y administrar recursos locales y en la nube.

Repositorio de código

El código de este patrón está disponible en el repositorio de soluciones Terraform Multi-Tenancy de GitHub EKS.

Prácticas recomendadas

Para ver las directrices y las mejores prácticas para el uso de esta implementación, consulte lo siguiente:

Epics

TareaDescripciónHabilidades requeridas

Clona el repositorio del proyecto.

Clone el repositorio de la solución Terraform Multi-Tenancy de GitHub EKS ejecutando el siguiente comando en una ventana de terminal:

git clone https://github.com/aws-samples/aws-eks-multitenancy-deployment.git
AWS DevOps

Inicie el bucket Terraform S3 y Amazon DynamoDB.

  1. En la bootstrap carpeta, abra el bootstrap.sh archivo y actualice los valores de las variables para el nombre del bucket de S3, el nombre de la tabla de DynamoDB y: Región de AWS

    S3_BUCKET_NAME="<S3_BUCKET_NAME>" DYNAMODB_TABLE_NAME="<DYNAMODB_NAME>" REGION="<AWS_REGION>"
  2. Ejecute el script bootstrap.sh. El script requiere el AWS CLI, que ha instalado como parte de los requisitos previos.

    cd bootstrap ./bootstrap.sh
AWS DevOps

Actualice los locals.tf archivos run.sh y.

  1. Cuando el proceso de arranque se complete correctamente, copie el bucket de S3 y el nombre de la tabla de DynamoDB de la sección variables del script: bootstrap.sh

    # Variables S3_BUCKET_NAME="<S3_BUCKET_NAME>" DYNAMODB_TABLE_NAME="<DYNAMODB_NAME"
  2. Pegue esos valores en el run.sh script, que se encuentra en el directorio raíz del proyecto:

    BACKEND_BUCKET_ID="<SAME_NAME_AS_S3_BUCKET_NAME>" DYNAMODB_ID="<SAME_NAME_AS_DYNAMODB_NAME>"
  3. Sube el código del proyecto a un CodeCommit repositorio. Puedes crear este repositorio automáticamente a través de Terraform configurando la siguiente variable true en el demo/pipeline/locals.tf archivo:

    create_new_repo = true
  4. Actualice el locals.tf archivo de acuerdo con sus requisitos para crear recursos de canalización.

AWS DevOps

Implemente el módulo Pipeline.

Para crear recursos de canalización, ejecuta los siguientes comandos de Terraform de forma manual. No hay ninguna organización para ejecutar estos comandos automáticamente.

./run.sh -m pipeline -e demo -r <AWS_REGION> -t init ./run.sh -m pipeline -e demo -r <AWS_REGION> -t plan ./run.sh -m pipeline -e demo -r <AWS_REGION> -t apply
AWS DevOps
TareaDescripciónHabilidades requeridas

Iniciar la canalización.

  1. En la templates carpeta, asegúrese de que los buildspec archivos tengan la siguiente variable establecida ennetwork:

    TF_MODULE_TO_BUILD: "network"
  2. En la CodePipeline consola, en la página de detalles de la canalización, inicia la canalización seleccionando Release change.

Tras esta primera ejecución, la canalización se iniciará automáticamente cada vez que realices un cambio en la rama principal del CodeCommit repositorio.

La canalización incluye las siguientes etapas:

  • validateinicializa Terraform, ejecuta los escaneos de seguridad de Terraform mediante las herramientas checkov y tfsec y carga los informes de escaneo en el bucket de S3.

  • plan muestra el plan de Terraform y lo carga en el depósito de S3.

  • applyaplica el resultado del plan Terraform del depósito de S3 y crea recursos. AWS

  • destroyelimina los AWS recursos creados durante la apply etapa. Para habilitar esta etapa opcional, defina la siguiente variable true en el demo/pipeline/locals.tf archivo:

    enable_destroy_stage = true
AWS DevOps

Valide los recursos creados a través del módulo de red.

Confirme que los siguientes AWS recursos se crearon después de que la canalización se implementara correctamente:

  • Una VPC de salida con tres subredes públicas y tres privadas, una puerta de enlace a Internet y una puerta de enlace NAT.

  • Una VPC de Amazon EKS con tres subredes privadas.

  • VPC de arrendatario 1 y arrendatario 2 con tres subredes privadas cada una.

  • Una puerta de enlace de tránsito con todos los adjuntos de la VPC y las rutas a cada subred privada.

  • Una ruta de puerta de enlace de tránsito estática para la VPC de salida de Amazon EKS con un bloque CIDR de destino de. 0.0.0.0/0 Esto es necesario para permitir que todas las VPC tengan acceso saliente a Internet a través de la VPC de salida de Amazon EKS.

AWS DevOps
TareaDescripciónHabilidades requeridas

Actualice locals.tf para permitir el acceso del CodeBuild proyecto a la VPC.

Para implementar los complementos para el clúster privado de Amazon EKS, el CodeBuild proyecto debe estar adjunto a la VPC de Amazon EKS.

  1. En la demo/pipeline carpeta, abra el locals.tf archivo y defina true la vpc_enabled variable en.

  2. Ejecute el run.sh script para aplicar los cambios al módulo de canalización:

    demo/pipeline/locals.tf ./run.sh -m pipeline -env demo -region <AWS_REGION> -tfcmd init ./run.sh -m pipeline -env demo -region <AWS_REGION> -tfcmd plan ./run.sh -m pipeline -env demo -region <AWS_REGION> -tfcmd apply
AWS DevOps

Actualice los buildspec archivos para crear el módulo de cómputo.

En la templates carpeta, en todos los archivos buildspec YAML, establece el valor de la TF_MODULE_TO_BUILD variable entrenetwork: compute

TF_MODULE_TO_BUILD: "compute"
AWS DevOps

Actualice el values archivo del diagrama Helm de administración de inquilinos.

  1. Abra el values.yaml archivo en la siguiente ubicación:

    cd cfg-terraform/demo/compute/cfg-tenant-mgmt

    El archivo tiene este aspecto:

    --- global: clusterRoles: operator: platform-tenant flux: flux-tenant-applier flux: tenantCloneBaseUrl: ${TEANT_BASE_URL} repoSecret: ${TENANT_REPO_SECRET} tenants: tenant-1: quotas: limits: cpu: 1 memory: 1Gi flux: path: overlays/tenant-1 tenant-2: quotas: limits: cpu: 1 memory: 2Gi flux: path: overlays/tenant-2
  2. En las tenants secciones global y, actualice la configuración en función de sus requisitos:

    • tenantCloneBaseUrl— Ruta al repositorio que aloja el código para todos los inquilinos (utilizamos el mismo repositorio de Git para todos los inquilinos)

    • repoSecret— El secreto de Kubernetes que contiene las claves SSH y los hosts conocidos para autenticarse en el repositorio Git de inquilinos global

    • quotas— Cuotas de recursos de Kubernetes que quieres aplicar a cada inquilino

    • flux path— Ruta a los archivos YAML de la aplicación de inquilinos en el repositorio global de inquilinos

AWS DevOps

Valide los recursos informáticos.

Tras actualizar los archivos en los pasos anteriores, se CodePipeline inicia automáticamente. Confirme que creó los siguientes AWS recursos para la infraestructura informática:

  • Clúster Amazon EKS con punto final privado

  • Nodos de trabajadores de Amazon EKS

  • Complementos de Amazon EKS: secretos externos y aws-loadbalancer-controller metrics-server

  • GitOps módulo, gráfico de Flux Helm, gráfico de Cilium Helm y gráfico de Helm de gestión de inquilinos

AWS DevOps
TareaDescripciónHabilidades requeridas

Valide los recursos de administración de inquilinos en Kubernetes.

Ejecuta los siguientes comandos para comprobar que los recursos de gestión de inquilinos se crearon correctamente con la ayuda de Helm.

  1. Se crearon los espacios de nombres de inquilinos, tal y como se especifica en: values.yaml

    kubectl get ns -A
  2. Las cuotas se asignan a cada espacio de nombres de inquilinos, tal y como se especifica en: values.yaml

    kubectl get quota --namespace=<tenant_namespace>
  3. Los detalles de las cuotas son correctos para cada espacio de nombres de inquilinos:

    kubectl describe quota cpu-memory-resource-quota-limit -n <tenant_namespace>
  4. Las políticas de Cilium Network se aplicaron a cada espacio de nombres de inquilinos:

    kubectl get CiliumNetworkPolicy -A
AWS DevOps

Verifique las implementaciones de las aplicaciones arrendatarias.

Ejecute los siguientes comandos para verificar que se hayan implementado las aplicaciones arrendatarias.

  1. Flux puede conectarse al CodeCommit repositorio especificado en el GitOps módulo:

    kubectl get gitrepositories -A
  2. El controlador de personalización de Flux ha desplegado los archivos YAML en el repositorio: CodeCommit

    kubectl get kustomizations -A
  3. Todos los recursos de la aplicación se implementan en sus espacios de nombres de inquilinos:

    kubectl get all -n <tenant_namespace>
  4. Se ha creado una entrada para cada inquilino:

    kubectl get ingress -n <tenant_namespace>

Resolución de problemas

ProblemaSolución

Aparece un mensaje de error similar al siguiente:

Failed to checkout and determine revision: unable to clone unknown error: You have successfully authenticated over SSH. You can use Git to interact with AWS CodeCommit.

Sigue estos pasos para solucionar el problema:

  1. Compruebe el repositorio de aplicaciones arrendatario: es posible que el error se deba a un repositorio vacío o mal configurado. Asegúrese de que el repositorio de aplicaciones arrendatarias contenga el código necesario.

  2. Vuelva a implementar el tenant_mgmt módulo: en el archivo de configuración del tenant_mgmt módulo, localice el app bloque y, a continuación, defina el deploy parámetro en: 0

    deploy = 0

    Tras ejecutar el apply comando Terraform, vuelva a cambiar el valor del deploy parámetro a: 1

    deploy = 1
  3. Vuelva a comprobar el estado: tras ejecutar los pasos anteriores, utilice el siguiente comando para comprobar si el problema persiste:

     kubectl get gitrepositories -A

    Si persiste, considere la posibilidad de profundizar en los registros de Flux para obtener más detalles o consulte la guía general de solución de problemas de Flux.

Recursos relacionados

Información adicional

A continuación, se muestra un ejemplo de estructura de repositorios para implementar aplicaciones arrendatarias:

applications sample_tenant_app ├── README.md ├── base │ ├── configmap.yaml │ ├── deployment.yaml │ ├── ingress.yaml │ ├── kustomization.yaml │ └── service.yaml └── overlays ├── tenant-1 │ ├── configmap.yaml │ ├── deployment.yaml │ └── kustomization.yaml └── tenant-2 ├── configmap.yaml └── kustomization.yaml