Versión 1.9

Agrega máquinas virtuales de Compute Engine a Anthos Service Mesh

Introducción

Anthos Service Mesh te permite administrar, observar y proteger los servicios que se ejecutan en grupos de instancias administrados (MIG), junto con los servicios que se ejecutan en los clústeres de Google Kubernetes Engine (GKE) en el malla. Esto te permite hacer lo siguiente con las instancias de Compute Engine en tu malla:

  • Administrar el tráfico
  • Aplicar mTLS
  • Aplicar control de acceso al tráfico de servicio
  • Acceder de forma segura a los servicios de Google Cloud
  • Recopilar métricas, registros y datos de seguimiento
  • Supervisar los servicios con Google Cloud Console

Esto permite que las aplicaciones heredadas que no sean adecuadas o que no estén listas para el uso de contenedores aprovechen las características de Anthos Service Mesh y permite integrar esas cargas de trabajo con el resto de tus servicios.

Cómo funciona

ASM proporciona dos definiciones de recursos personalizados (CRD) relacionadas para representar cargas de trabajo de máquinas virtuales:

  • WorkloadGroup representa un grupo lógico de cargas de trabajo de máquinas virtuales que comparten propiedades comunes. Esto es similar a una implementación en Kubernetes.
  • WorkloadEntry representa una única instancia de una carga de trabajo de máquina virtual. Esto es similar a un pod en Kubernetes.
  • Luego, Service puede seleccionar WorkloadGroup y tener tráfico de ruta ASM para la instancia de VM de una manera similar a Pod. Esto permite que la VM actúe como cualquier otra carga de trabajo en la malla.

Debes crear una plantilla de instancias de Compute Engine para cada grupo de instancias de Compute Engine, que especifica un agente de proxy de servicio para cada instancia de Compute Engine en ese grupo. Durante la instalación, el agente inicializa el proxy de servicio, configura la intercepción del tráfico y supervisa el estado del proxy de servicio durante la vida útil de la instancia de Compute Engine. El proxy se conecta con el plano de control de Anthos Service Mesh y, luego, registra automáticamente cada instancia de Compute Engine como una WorkloadEntry para el WorkloadGroup correspondiente. Esto permite que Anthos Service Mesh trate a cada instancia como un extremo de servicio, como los pods de Kubernetes en el clúster. También puedes crear servicios de Kubernetes para cargas de trabajo de VM, como lo harías con pods de Kubernetes.

Para aumentar o reducir la cantidad de cargas de trabajo en instancias de Compute Engine, comenzando por un tamaño mínimo del MIG de cero, consulta Ajuste de escala automático en grupos de instancias.

El agente de proxy de servicio se basa en VM Manager para garantizar que el agente se instale en cada VM en el MIG. Para obtener más información sobre los grupos de instancias y la administración de VM, consulta Grupo de instancias administrado (MIG) y VM Manager.

Limitaciones

  • El plano de control de la malla debe ser Anthos Service Mesh 1.9 o superior.
  • Solo se admiten los grupos de instancias administrados de Compute Engine creados a partir de una plantilla de instancias de Compute Engine.
  • Solo se admite el SO Debian en Compute Engine. Consulta la asistencia de Debian para obtener más información.
  • El clúster y las VM deben estar en la misma red, en el mismo proyecto y usar una única interfaz de red.
  • Puedes usar esta característica sin una suscripción a Anthos, pero ciertos elementos de la IU y las funciones de Google Cloud Console solo están disponibles para los suscriptores de Anthos. Si quieres obtener información sobre lo que está disponible para suscriptores y no suscriptores, consulta las diferencias en la IU de Anthos Service Mesh y Anthos.

Requisitos previos

Antes de comenzar, verifica los siguientes requisitos previos.

Clústeres

En esta página, se incluye la opción de instalar Anthos Service Mesh como parte de sus pasos o actualizar un clúster que ya tiene Anthos Service Mesh instalado. En cualquier caso, estos pasos requieren Anthos Service Mesh 1.9 y un clúster que cumple con estos requisitos. Además, la asistencia de VM de Anthos Service Mesh tiene más requisitos:

  • El plano de control debe instalarse en un clúster que controles. No se admiten los planos de control administrados por Google. Para obtener más información, consulta los planos de control administrados por Google.
  • Usa la CA de Mesh como autoridad certificadora.
  • Usa Stackdriver para la telemetría.
  • Tiene la implementación Canonical Service habilitada, que el proceso de instalación de Anthos Service Mesh habilita de forma automática.

Tu clúster debe estar registrado en un environ. Sin embargo, si aún no está registrado, el proceso de instalación de VM puede registrarlo en el proyecto especificado.

Si tienes una suscripción a Anthos, habilita la API de Anthos.

Habilitar la API

Herramientas de la CLI

El proceso de instalación requiere las siguientes herramientas, que ya están instaladas si usas Google Cloud Shell:

  • gcloud
  • kubectl
  • kpt
  • curl
  • jq
  • awk
  • printf
  • tr
  • grep
  • tail

Descarga la secuencia de comandos

En esta sección, se describe cómo descargar la secuencia de comandos para la integración de VM.

  1. Descarga la secuencia de comandos de VM para Anthos Service Mesh 1.9.1 en el directorio de trabajo actual:

    curl https://storage.googleapis.com/csm-artifacts/asm/asm_vm_1.9 > asm_vm
    
  2. Descarga el SHA-256 del archivo en el directorio de trabajo actual:

    curl https://storage.googleapis.com/csm-artifacts/asm/asm_vm_1.9.sha256 > asm_vm.sha256
    
  3. Con ambos archivos en el mismo directorio, verifica la descarga:

    sha256sum -c --ignore-missing asm_vm.sha256
    

    Si la verificación se realiza de forma correcta, el comando muestra asm_vm: OK. Por compatibilidad, el comando anterior incluye la marca --ignore-missing para permitir que cualquier versión de la secuencia de comandos cambie su nombre a asm_vm.

  4. Haz que la secuencia de comandos sea ejecutable:

    chmod +x asm_vm
    

Comenzar

En esta sección, se explican los pasos para agregar instancias de Compute Engine a Anthos Service Mesh.

Configure su entorno

  1. Usa gcloud para configurar tu herramienta de kubectl para apuntar al clúster que especificaste, ya que algunos de los pasos siguientes requieren que realices cambios directamente en el clúster.

    gcloud container clusters get-credentials CLUSTER_NAME --zone CLUSTER_LOCATION --project PROJECT_ID
    

Prepara tu clúster

Prepara el clúster de Anthos Service Mesh para VM mediante la preparación del plano de control de Anthos Service Mesh 1.9

Selecciona el siguiente paso en función de si Anthos Service Mesh 1.9 ya está instalado en tu clúster.

No instalado

Si Anthos Service Mesh 1.9 no se instaló en tu clúster, en el siguiente ejemplo se muestra cómo agregar las opciones vm y hub-meshca para modificar los pasos de instalación habituales de Anthos Service Mesh proporcionados en Instalación, migración y actualización para GKE. También se explica cómo descargar la secuencia de comandos install_asm que se usa en el siguiente ejemplo.

Después de descargar la secuencia de comandos install_asm, puedes instalar Anthos Service Mesh en tu clúster si incluyes las marcas --option hub-meshca, --option vm y --enable_all. Para obtener más información, consulta Habilita la CA de Mesh con Environ y Marcas de habilitación.

./install_asm --project_id PROJECT_ID \
--cluster_name CLUSTER_NAME \
--cluster_location CLUSTER_LOCATION \
--mode install --option vm --option hub-meshca \
--enable_all

Instalada

Si Anthos Service Mesh 1.9 ya se instaló en tu clúster, simplemente actualiza el plano de control de Anthos Service Mesh para admitir las cargas de trabajo basadas en VM. La secuencia de comandos también te ayuda a verificar si tu instalación de Anthos Service Mesh en el clúster está lista para las cargas de trabajo de VM. En particular, el subcomando prepare_cluster actualiza todas las revisiones de Anthos Service Mesh 1.9 a fin de estar listas para las cargas de trabajo de VM.

./asm_vm prepare_cluster \
--project_id PROJECT_ID \
--cluster_name CLUSTER_NAME \
--cluster_location CLUSTER_LOCATION

Los pasos anteriores realizan las siguientes acciones por ti:

  1. Habilita el registro automático de VM: Esto se logra mediante la configuración de las variables PILOT_ENABLE_WORKLOAD_ENTRY_AUTOREGISTRATION y PILOT_ENABLE_CROSS_CLUSTER_WORKLOAD_ENTRY en verdadero. Cuando esto esté habilitado, se crearán nuevas instancias de VM con WorkloadGroup y se creará una nueva WorkloadEntry para enrutar el tráfico a la VM. Todos los planos de control de Anthos Service Mesh 1.9 instalados con install_asm se incluirán de forma predeterminada.

  2. Instalar una puerta de enlace de expansión: Esta puerta de enlace se llama puerta de enlace eastwest y se define en el paquete de configuración de Anthos Service Mesh. Esto también expondrá el plano de control a las VM.

  3. Instala la CRD IdentityProvider y registra una CR IdentityProvider de Google para permitir que las VM se autentiquen en el plano de control de Anthos Service Mesh y se comuniquen de forma segura con el resto de la malla de servicios.

  4. Registra el clúster en un Environ y habilita Workload Identity, si usas --enable_all o --enable_registration en la secuencia de comandos install_asm.

  5. Habilita la característica Service Mesh en el environ. Esta característica administrará las políticas necesarias para permitir que las VM se comuniquen de forma segura con la malla.

Agrega tus VM

En esta sección, agregarás instancias de Compute Engine a la malla según la plantilla de instancias que crees con la secuencia de comandos asm_vm. La secuencia de comandos solo genera la configuración necesaria para el agente del proxy de servicio. Para incluir más configuración en tu plantilla de instancias, crea una plantilla de instancias de origen y agrégala a la secuencia de comandos.

Para agregar VM a tu malla, sigue estos pasos:

  1. Configura las siguientes variables de entorno para usarlas en pasos posteriores. Configura estas variables para cada carga de trabajo de la VM:

    • WORKLOAD_NAME es el nombre de la carga de trabajo de la que forma parte la VM, que debe ser un subdominio DNS-1123 compatible que contenga caracteres alfanuméricos en minúscula.
    • WORKLOAD_VERSION es la versión de la carga de trabajo de la que forma parte la VM. Opcional.
    • WORKLOAD_SERVICE_ACCOUNT es la cuenta de servicio de GCP que ejecuta la VM.
    • WORKLOAD_NAMESPACE es el espacio de nombres de la carga de trabajo.
    • ASM_INSTANCE_TEMPLATE es el nombre de la plantilla de instancias que se creará. El nombre de la plantilla de instancias de Compute Engine no admite guiones bajos.
    • SOURCE_INSTANCE_TEMPLATE es el nombre de la plantilla en la que se basa la plantilla generada. Opcional.
  2. Crea el espacio de nombres para las cargas de trabajo de VM si aún no existe:

    kubectl create ns WORKLOAD_NAMESPACE
    
  3. Etiqueta el espacio de nombres con la revisión del plano de control. Para ver un ejemplo de cómo encontrar la revisión del plano de control que se muestra como REVISION en el siguiente ejemplo, consulta Implementa y vuelve a implementar las cargas de trabajo.

    kubectl label ns WORKLOAD_NAMESPACE istio-injection- istio.io/rev=REVISION --overwrite
    
  4. Crea el WorkloadGroup para que las VM se registren:

    kubectl apply -f - << EOF
    apiVersion: networking.istio.io/v1alpha3
    kind: WorkloadGroup
    metadata:
     name: WORKLOAD_NAME
     namespace: WORKLOAD_NAMESPACE
    spec:
     metadata:
       labels:
         app.kubernetes.io/name: WORKLOAD_NAME
         app.kubernetes.io/version: WORKLOAD_VERSION
       annotations:
         security.cloud.google.com/IdentityProvider: google
     template:
       serviceAccount: WORKLOAD_SERVICE_ACCOUNT
    EOF
    
    Campo Descripción
    name El nombre de la carga de trabajo de la que forma parte la VM.
    namespace El espacio de nombres del que forma parte la carga de trabajo.
    app.kubernetes.io/name Las etiquetas recomendadas para las aplicaciones de Kubernetes Puedes usar tus propias etiquetas para las cargas de trabajo de VM.
    app.kubernetes.io/version Las etiquetas recomendadas para las aplicaciones de Kubernetes Puedes usar tus propias etiquetas para las cargas de trabajo de VM.
    serviceAccount La identidad de la cuenta de servicio que usan la VM y el proyecto, que se usará como parte de la identidad de la carga de trabajo en el formato SPIFFE. Para obtener más información, consulta Cuentas de servicio.
    security.cloud.google.com/IdentityProvider El proveedor de identidad que usará la VM, que ya debería estar registrado en tu clúster. Para las VM de Compute Engine, debe configurarse como google. “IdentityProvider” le dice al plano de control cómo autenticar la credencial de la VM y dónde extraer la cuenta de servicio de la VM.
  5. Ejecuta la secuencia de comandos asm_vm con las siguientes opciones y marcas a fin de crear una plantilla de instancias para tus instancias de Compute Engine de Anthos Service Mesh.

    La secuencia de comandos verifica los requisitos previos del clúster, agrega etiquetas de VM para Anthos Service Mesh, genera la configuración de metadatos personalizados para el agente del proxy de servicio y crea una plantilla de instancias nueva.

    Si tienes una plantilla de instancias existente en la que deseas que se base la secuencia de comandos, puedes especificar la opción --source_instance_template. Si tu plantilla de instancias existente incluye una secuencia de comandos de inicio que requiere conectividad de red, la secuencia de comandos debe ser resistente a los problemas de conectividad de la red transitorios. Consulta la aplicación de demostración para ver un ejemplo de cómo agregar resiliencia a la interrupción de red temporal.

    ./asm_vm create_gce_instance_template \
    ASM_INSTANCE_TEMPLATE \
    --project_id PROJECT_ID \
    --cluster_location CLUSTER_LOCATION \
    --cluster_name CLUSTER_NAME \
    --workload_name WORKLOAD_NAME \
    --workload_namespace WORKLOAD_NAMESPACE \
    --source_instance_template SOURCE_INSTANCE_TEMPLATE
    

    Opciones

    Opción Descripción
    -p|--project_id PROJECT_ID Es el ID del proyecto en el que se creó el clúster.
    -n|--cluster_name CLUSTER_NAME Es el nombre del clúster.
    -l|--cluster_location CLUSTER_LOCATION Es la zona (para los clústeres de zona única) o la región (para los clústeres regionales) en la que se creó el clúster.
    -w|--workload_name WORKLOAD_NAME El nombre de la carga de trabajo que representan las instancias de Compute Engine.
    --workload_namespace WORKLOAD_NAMESPACE Opcional. El espacio de nombres de la carga de trabajo. El valor predeterminado es “default”.
    -s|--source_instance_template SOURCE_INSTANCE_TEMPLATE_NAME Opcional. Una plantilla de instancias existente que se usa como base para la plantilla de instancias de Anthos Service Mesh Compute Engine. Si no se especifica, se crea una plantilla de instancias con valores predeterminados.

    Marcas

    Flag Descripción
    -v|--verbose Imprime comandos antes y después de la ejecución.
    --dry_run Imprime comandos, pero no los ejecuta.
    --only_validate Ejecuta la validación, pero no crea una nueva plantilla de instancias de Compute Engine.
    -h|--help Muestra un mensaje de ayuda que describe las opciones y las marcas, y se cierra.
  6. Establece las siguientes variables de entorno para cada MIG que crees:

    • INSTANCE_GROUP_NAME es el nombre del grupo de instancias de Compute Engine que se creará.
    • ASM_INSTANCE_TEMPLATE es el nombre de la plantilla de instancias que se creará. El nombre de la plantilla de instancias de Compute Engine no admite guiones bajos.
    • INSTANCE_GROUP_ZONE es la zona del grupo de instancias de Compute Engine que se creará.
    • PROJECT_ID es el ID del proyecto en el que se creó el clúster.
    • SIZE es el tamaño del grupo de instancias que se creará. Se puede cambiar después de la creación del grupo de instancias.
    • WORKLOAD_NAME es el nombre de la carga de trabajo de la que forma parte la VM.
    • WORKLOAD_NAMESPACE es el espacio de nombres de la carga de trabajo.
  7. Crea un grupo de instancias administrado para las cargas de trabajo de VM mediante las variables creadas en los pasos anteriores:

    gcloud compute instance-groups managed create \
    INSTANCE_GROUP_NAME \
    --template ASM_INSTANCE_TEMPLATE \
    --zone=INSTANCE_GROUP_ZONE \
    --project=PROJECT_ID \
    --size=SIZE
    

    Para aumentar o reducir la cantidad de cargas de trabajo en instancias de Compute Engine, comenzando desde un tamaño de MIG zonal o regional de cero, consulta Ajuste de escala automático para grupos de instancias. Para obtener más información sobre la creación de grupos, consulta gcloud compute instance-groups managed create.

    Cuando se inicie la instancia, se autenticará de forma automática con el plano de control de Anthos Service Mesh en tu clúster y el plano de control registrará cada VM como una WorkloadEntry.

  8. Cuando la instancia de VM en el MIG termine de iniciarse, puedes ver las VM registradas en el espacio de nombres de la carga de trabajo con el siguiente comando:

       kubectl get workloadentry -n WORKLOAD_NAMESPACE
    
  9. Agrega un servicio de Kubernetes para exponer las cargas de trabajo de VM que se agregaron antes. Asegúrate de que el servicio seleccione la etiqueta correspondiente en la VM WorkloadGroup registrada anteriormente para el enrutamiento de tráfico correcto.

    En el siguiente ejemplo, se crea un servicio de Kubernetes llamado WORKLOAD_NAME en el espacio de nombres WORKLOAD_NAMESPACE que expone las cargas de trabajo de la VM con la etiqueta app.kubernetes.io/name: WORKLOAD_NAME en el puerto HTTP 80.

    kubectl apply -f - << EOF
    apiVersion: v1
    kind: Service
    metadata:
     name: WORKLOAD_NAME
     namespace: WORKLOAD_NAMESPACE
     labels:
       asm_resource_type: VM
    spec:
     ports:
     - port: 80
       name: http
     selector:
       app.kubernetes.io/name: WORKLOAD_NAME
    EOF
    

    Para obtener más detalles sobre cómo crear un servicio de Kubernetes, consulta https://kubernetes.io/docs/concepts/services-networking/service/#defining-a-service.

  10. Para usar una aplicación de muestra en tu VM, consulta Implementa una aplicación de muestra.

Actualización del plano de control de Anthos Service Mesh

Actualiza tu plano de control de Anthos Service Mesh a una versión nueva mediante las instrucciones que se muestran en Actualiza Anthos Service Mesh a la versión más reciente. Después de instalar una versión nueva del plano de control de Anthos Service Mesh, vuelve a implementar las cargas de trabajo de Kubernetes con las instrucciones que se indican en Implementa y vuelve a implementar las cargas de trabajo.

Para las cargas de trabajo de VM, crea una plantilla de instancias nueva y realiza una actualización progresiva a las VM en tu MIG:

  1. Usa el siguiente comando para encontrar la etiqueta de revisión en istiod:

    kubectl -n istio-system get pods -l app=istiod --show-labels
    

    El resultado del comando es similar al siguiente: Ten en cuenta que el resultado de las migraciones es un poco diferente al de las actualizaciones. El siguiente resultado de ejemplo es de una migración.

    NAME                                READY   STATUS    RESTARTS   AGE   LABELS
    istiod-7744bc8dd7-qhlss             1/1     Running   0          49m   app=istiod,istio.io/rev=default,istio=pilot,pod-template-hash=7744bc8dd7
    istiod-asm-191-1-85d86774f7-flrt2   1/1     Running   0          26m   app=istiod,istio.io/rev=asm-191-1,istio=istiod,pod-template-hash=85d86774f7
    istiod-asm-191-1-85d86774f7-tcwtn   1/1     Running   0          26m   app=istiod,istio.io/rev=asm-191-1,istio=istiod,pod-template-hash=85d86774f7
    1. En el resultado, en la columna LABELS, observa el valor de la etiqueta de revisión istiod de la versión nueva, que está después del prefijo istio.io/rev=. En este ejemplo, el valor es asm-191-1.

    2. Observa también el valor en la etiqueta de revisión de la versión istiod anterior. Necesitarás esto para borrar la versión anterior de istiod cuando termines de migrar las cargas de trabajo a la versión nueva. En el resultado de ejemplo, el valor en la etiqueta de revisión para la versión anterior de istiod es default.

  2. Agrega la etiqueta de revisión a un espacio de nombres y quita la etiqueta istio-injection (si existe). En el siguiente comando, cambia REVISION por el valor que coincide con la nueva revisión de istiod.

    kubectl label namespace NAMESPACE istio.io/rev=REVISION istio-injection- --overwrite

    Si ves "istio-injection not found" en el resultado, puedes ignorarlo. Esto significa que el espacio de nombres no tenía la etiqueta istio-injection antes. Debido a que la inserción automática falla si un espacio de nombres tiene tanto la istio-injection como la etiqueta de revisión, todos los comandos kubectl label de la documentación de Anthos Service Mesh incluyen la acción de quitar la etiqueta istio-injection.

  3. Crea una plantilla de instancias nueva con la secuencia de comandos asm_vm. Asegúrate de usar un nombre de plantilla de instancias nuevo y de incluir la misma plantilla de instancia de origen, si tenías una para la misma carga de trabajo.

    ./asm_vm create_gce_instance_template \
    NEW_ASM_INSTANCE_TEMPLATE \
    --project_id PROJECT_ID \
    --cluster_location CLUSTER_LOCATION \
    --cluster_name CLUSTER_NAME \
    --workload_name WORKLOAD_NAME \
    --workload_namespace WORKLOAD_NAMESPACE \
    --source_instance_template SOURCE_INSTANCE_TEMPLATE
    
  4. Realiza una actualización progresiva a tu MIG existente para la carga de trabajo.

    Para obtener más información, consulta Inicia una actualización progresiva básica.

    gcloud compute instance-groups managed rolling-action start-update INSTANCE_GROUP_NAME \
    --version=template=NEW_ASM_INSTANCE_TEMPLATE \
    --zone=INSTANCE_GROUP_ZONE
    
  5. Prueba la carga de trabajo de la VM para asegurarte de que funciona según lo esperado.

Actualiza aplicaciones de VM

Si tienes actualizaciones en tu aplicación, incluidos cambios en WorkloadGroup o en tu plantilla de instancias de origen, se requiere una plantilla de instancias nueva para actualizar el MIG de tus cargas de trabajo de VM.

Cuando se aplica el cambio WorkloadGroup o se crea la plantilla de instancias de origen nueva, crearás una plantilla de instancias nueva para Anthos Service Mesh y realizarás una actualización progresiva a las VM en tu MIG.

  1. Crea una plantilla de instancias nueva con la secuencia de comandos asm_vm. Asegúrate de usar un nombre de plantilla de instancias nuevo y de incluir la plantilla de instancia de origen nueva si creaste una para la actualización de tu aplicación.

    ./asm_vm create_gce_instance_template \
    NEW_ASM_INSTANCE_TEMPLATE \
    --project_id PROJECT_ID \
    --cluster_location CLUSTER_LOCATION \
    --cluster_name CLUSTER_NAME \
    --workload_name WORKLOAD_NAME \
    --workload_namespace WORKLOAD_NAMESPACE \
    --source_instance_template NEW_SOURCE_INSTANCE_TEMPLATE
    
  2. Realiza una actualización progresiva a tu MIG existente para la carga de trabajo. Para obtener más información sobre cómo usar la actualización progresiva de MIG, consulta Inicia una actualización progresiva básica.

    gcloud compute instance-groups managed rolling-action start-update INSTANCE_GROUP_NAME \
    --version=template=NEW_ASM_INSTANCE_TEMPLATE \
    --zone=INSTANCE_GROUP_ZONE
    
  3. Prueba la carga de trabajo de la VM para asegurarte de que funcione como se espera.

Implementar una aplicación de muestra

Para demostrar que la configuración de malla nueva funciona correctamente, puedes instalar la aplicación de muestra de Bookinfo. En este ejemplo, se ejecuta una base de datos de MySQL en la VM y el servicio de calificaciones lee los valores de calificación de la base de datos.

Instala Bookinfo en el clúster

Sigue estos pasos para implementar los servicios de la aplicación Bookinfo con los proxies de sidecar incorporados en cada servicio. La aplicación BookInfo se implementará en el espacio de nombres default.

  1. En la línea de comandos de la computadora en la que instalaste Anthos Service Mesh, ve a la raíz del directorio de instalación de Anthos Service Mesh que creaste en el paso Descarga la secuencia de comandos.

  2. Para habilitar la inserción automática del sidecar, usa el siguiente comando a fin de localizar la etiqueta en istiod, que contiene el valor de la etiqueta de revisión que se usará en pasos posteriores.

    kubectl -n istio-system get pods -l app=istiod --show-labels
    

    El resultado es similar al siguiente:

    NAME                                READY   STATUS    RESTARTS   AGE   LABELS
    istiod-asm-191-1-5788d57586-bljj4   1/1     Running   0          23h   app=istiod,istio.io/rev=asm-191-1,istio=istiod,pod-template-hash=5788d57586
    istiod-asm-191-1-5788d57586-vsklm   1/1     Running   1          23h   app=istiod,istio.io/rev=asm-191-1,istio=istiod,pod-template-hash=5788d57586
    

    En el resultado, en la columna LABELS, observa el valor de la etiqueta de revisión istiod, que está después del prefijo istio.io/rev=. En este ejemplo, el valor es asm-191-1.

  3. Aplica la etiqueta de revisión al espacio de nombres default. En el siguiente comando, REVISION es el valor de la etiqueta de revisión istiod que anotaste en el paso anterior.

    kubectl label namespace default istio-injection- istio.io/rev=REVISION --overwrite
    

    Puedes ignorar el mensaje "istio-injection not found" en el resultado. Esto significa que el espacio de nombres no tenía la etiqueta istio-injection, que debería aparecer en las nuevas instalaciones de Anthos Service Mesh o en implementaciones nuevas. Debido a que la inserción automática falla si un espacio de nombres tiene tanto la istio-injection como la etiqueta de revisión, todos los comandos kubectl label de la documentación de Anthos Service Mesh incluyen la acción de quitar la etiqueta istio-injection.

  4. Implementa tu aplicación en el espacio de nombres predeterminado mediante kubectl:

    kubectl apply -f samples/bookinfo/platform/kube/bookinfo.yaml
    
  5. Confirma que la aplicación se implementó correctamente ejecutando los siguientes comandos:

    kubectl get services
    

    Resultado esperado:

    NAME                       CLUSTER-IP   EXTERNAL-IP   PORT(S)              AGE
    details                    10.0.0.31    <none>        9080/TCP             6m
    kubernetes                 10.0.0.1     <none>        443/TCP              7d
    productpage                10.0.0.120   <none>        9080/TCP             6m
    ratings                    10.0.0.15    <none>        9080/TCP             6m
    reviews                    10.0.0.170   <none>        9080/TCP             6m

    y

    kubectl get pod
    

    Resultado esperado:

    NAME                                        READY     STATUS    RESTARTS   AGE
    details-v1-1520924117-48z17                 2/2       Running   0          6m
    productpage-v1-560495357-jk1lz              2/2       Running   0          6m
    ratings-v1-734492171-rnr5l                  2/2       Running   0          6m
    reviews-v1-874083890-f0qf0                  2/2       Running   0          6m
    reviews-v2-1343845940-b34q5                 2/2       Running   0          6m
    reviews-v3-1813607990-8ch52                 2/2       Running   0          6m
  6. Finalmente, define el enrutamiento de la puerta de enlace para la aplicación:

    kubectl apply -f samples/bookinfo/networking/bookinfo-gateway.yaml
    

    Resultado esperado:

    gateway.networking.istio.io/bookinfo-gateway created
    virtualservice.networking.istio.io/bookinfo created
  7. Confirma que se pueda acceder a la página del producto.

    export INGRESS_HOST=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
    export INGRESS_PORT=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.spec.ports[?(@.name=="http2")].port}')
    export GATEWAY_URL="${INGRESS_HOST}:${INGRESS_PORT}"
    curl -s "http://${GATEWAY_URL}/productpage" | grep -o "<title>.*</title>"
    

    Resultado esperado:

    <title>Simple Bookstore App</title>
    

Crea instancias de Compute Engine y, luego, instala MySQL

En este paso, crearás una plantilla de instancia de Compute Engine para la instancia de MySQL que se ejecuta en la VM. Para obtener pasos más detallados, consulta Bookinfo con una máquina virtual.

  1. Crea una plantilla de instancias de Compute Engine que incluya una secuencia de comandos de inicio para instalar MySQL y agrega una base de datos de calificaciones en el inicio.

    cat << "EOF" > init-mysql
    #!/bin/bash
    
    # Wait until Envoy is ready before installing mysql
    while true; do
      rt=$(curl -s 127.0.0.1:15000/ready)
      if [[ $? -eq 0 ]] && [[ "${rt}" -eq "LIVE" ]]; then
        echo "envoy is ready"
        break
      fi
      sleep 1
    done
    
    sudo apt-get update && sudo apt-get install -y mariadb-server
    
    sudo sed -i '/bind-address/c\bind-address  = 0.0.0.0' /etc/mysql/mariadb.conf.d/50-server.cnf
    
    cat <<EOD | sudo mysql
    # Grant access to root
    GRANT ALL PRIVILEGES ON *.* TO 'root'@'localhost' IDENTIFIED BY 'password' WITH GRANT OPTION;
    
    # Grant root access to other IPs
    CREATE USER 'root'@'%' IDENTIFIED BY 'password';
    GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' WITH GRANT OPTION;
    FLUSH PRIVILEGES;
    quit;
    EOD
    
    sudo systemctl restart mysql
    
    curl -LO https://raw.githubusercontent.com/istio/istio/release-1.9/samples/bookinfo/src/mysql/mysqldb-init.sql
    
    mysql -u root -ppassword < mysqldb-init.sql
    EOF
    
    gcloud compute \
    --project=PROJECT_ID \
    instance-templates create mysql-instance-template \
    --machine-type=e2-medium \
    --metadata-from-file=startup-script=init-mysql \
    --image=debian-10-buster-v20201014 \
    --image-project=debian-cloud \
    --boot-disk-size=10GB
    
  2. Crea un WorkloadGroup para la carga de trabajo de MySQL.

    kubectl apply -f - << EOF
    apiVersion: networking.istio.io/v1alpha3
    kind: WorkloadGroup
    metadata:
     name: mysql
     namespace: default
    spec:
     metadata:
       labels:
         app.kubernetes.io/name: mysql
       annotations:
         security.cloud.google.com/IdentityProvider: google
     template:
       serviceAccount: WORKLOAD_SERVICE_ACCOUNT
    EOF
    
  3. Usa la secuencia de comandos de VM anterior a fin de crear una plantilla de instancias nueva para preparar las instancias para tu malla.

    ./asm_vm create_gce_instance_template \
    asm-mysql-instance-template \
    --project_id PROJECT_ID \
    --cluster_location CLUSTER_LOCATION \
    --cluster_name CLUSTER_NAME \
    --workload_name mysql \
    --source_instance_template mysql-instance-template
    
  4. Crea un MIG de Compute Engine con la plantilla de instancias recién creada.

    gcloud compute instance-groups managed create mysql-instance \
    --template asm-mysql-instance-template \
    --zone=us-central1-c \
    --project=PROJECT_ID \
    --size=1
    

Creación de servicio

Crea un servicio de Kubernetes para el servicio de MySQL.

  1. Crea un servicio de Kubernetes con el siguiente comando:

    kubectl apply -f - << EOF
    apiVersion: v1
    kind: Service
    metadata:
     name: mysql
     namespace: default
     labels:
       asm_resource_type: VM
    spec:
     ports:
     - name: mysql
       port: 3306
       protocol: TCP
       targetPort: 3306
     selector:
       app.kubernetes.io/name: mysql
    EOF
    

Usa el panel de IU de Anthos

Para ver el nuevo servicio basado en VM que creaste, haz clic en Anthos > Service Mesh en la barra de navegación principal izquierda. Se mostrará una tabla de los servicios que se ejecutan en tu malla. El servicio que agregaste debería aparecer en la tabla con un valor Type de VM y algunas métricas de alto nivel. Para ver más telemetría de tu servicio basado en VM, haz clic en el nombre del servicio, que te mostrará el panel de nivel de servicio.

Para obtener más información sobre cómo usar el panel de IU de Anthos, consulta Explora Anthos Service Mesh en Cloud Console.

Administra el tráfico a las cargas de trabajo de la VM

Puedes cambiar las reglas de red para controlar cómo fluye el tráfico dentro y fuera de las VM.

Controla el tráfico a un nuevo servicio de calificaciones (de pod a VM)

Crea otro servicio de calificaciones en Bookinfo que use la instancia de MySQL creada antes como fuente de datos y especifica una regla de enrutamiento que exija que el servicio de revisión use el nuevo servicio de calificaciones.

  1. Crea un nuevo servicio de calificación para usar la instancia de MySQL.

    kubectl apply -f - << EOF
    apiVersion: apps/v1
    kind: Deployment
    metadata:
     name: ratings-v2-mysql-vm
     labels:
       app: ratings
       version: v2-mysql-vm
    spec:
     replicas: 1
     selector:
       matchLabels:
         app: ratings
         version: v2-mysql-vm
     template:
       metadata:
         labels:
           app: ratings
           version: v2-mysql-vm
       spec:
         serviceAccountName: bookinfo-ratings
         containers:
         - name: ratings
           image: docker.io/istio/examples-bookinfo-ratings-v2:1.16.2
           imagePullPolicy: IfNotPresent
           env:
             - name: DB_TYPE
               value: "mysql"
             - name: MYSQL_DB_HOST
               value: mysql.default.svc.cluster.local
             - name: MYSQL_DB_PORT
               value: "3306"
             - name: MYSQL_DB_USER
               value: root
             - name: MYSQL_DB_PASSWORD
               value: password
           ports:
           - containerPort: 9080
    EOF
    
  2. Crea una regla de enrutamiento.

    kubectl apply -f - << EOF
    apiVersion: networking.istio.io/v1alpha3
    kind: VirtualService
    metadata:
     name: reviews
    spec:
     hosts:
     - reviews
     http:
     - route:
       - destination:
           host: reviews
           subset: v3
    ---
    apiVersion: networking.istio.io/v1alpha3
    kind: VirtualService
    metadata:
     name: ratings
    spec:
     hosts:
     - ratings
     http:
     - route:
       - destination:
           host: ratings
           subset: v2-mysql-vm
    EOF
    
  3. Aplica reglas de destino para los servicios creados.

    kubectl apply -f - << EOF
    apiVersion: networking.istio.io/v1alpha3
    kind: DestinationRule
    metadata:
     name: reviews
    spec:
     host: reviews
     subsets:
     - name: v1
       labels:
         version: v1
     - name: v2
       labels:
         version: v2
     - name: v3
       labels:
         version: v3
    ---
    apiVersion: networking.istio.io/v1alpha3
    kind: DestinationRule
    metadata:
     name: ratings
    spec:
     host: ratings
     subsets:
     - name: v1
       labels:
         version: v1
     - name: v2
       labels:
         version: v2
     - name: v2-mysql
       labels:
         version: v2-mysql
     - name: v2-mysql-vm
       labels:
         version: v2-mysql-vm
    EOF
    

Valida la implementación de la aplicación

Para comprobar que la aplicación Bookinfo funcione, envía tráfico a la puerta de enlace de entrada.

  • Si instalaste Anthos Service Mesh en GKE, obtén la dirección IP externa de la puerta de enlace de entrada que creaste en los pasos anteriores:

    kubectl get svc istio-ingressgateway -n istio-system
    

    Salida:

    NAME                   TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)                                      AGE
    istio-ingressgateway   LoadBalancer   10.19.247.233   35.239.7.64   80:31380/TCP,443:31390/TCP,31400:31400/TCP   27m

    En este ejemplo, la dirección IP del servicio de entrada es 35.239.7.64.

Prueba la aplicación

  1. Verifica que la app Bookinfo se ejecute con curl:

    curl -I http://EXTERNAL_IP/productpage
    

    Si la respuesta muestra 200, significa que la aplicación funciona de forma correcta con Anthos Service Mesh.

  2. Para ver la página web de Bookinfo, ingresa la siguiente dirección en tu navegador:

    http://EXTERNAL_IP/productpage
    
  3. En la página principal de la aplicación Bookinfo, verifica que se muestren cinco estrellas de Reviewer1 y cuatro estrellas de Reviewer2.

Aplica seguridad en las cargas de trabajo de VM

Aplicar la seguridad en las cargas de trabajo de la VM es lo mismo que aplicar la seguridad en las cargas de trabajo de Kubernetes. Para obtener más información, consulta Seguridad de Istio.

Después de completar los pasos anteriores, tu VM de Compute Engine tendrá un certificado de carga de trabajo emitido por Google. En el certificado, el valor SubjectAlternativeName muestra la identidad de la carga de trabajo de Anthos de la VM en el formato spiffe://<workload_identity_pool>/ns/WORKLOAD_NAMESPACE/sa/WORKLOAD_SERVICE_ACCOUNT.

Para obtener más información, consulta Grupo de identidad de carga de trabajo.

Habilita el modo estricto mTLS para la malla

Aplica el siguiente YAML para aplicar el mTLS estricto en toda la malla.

kubectl apply -f - << EOF
apiVersion: security.istio.io/v1beta1
kind: PeerAuthentication
metadata:
  name: default
  namespace: istio-system
spec:
  mtls:
    mode: STRICT
EOF

Autorización para el tráfico de servicio a servicio

Usa AuthorizationPolicy para controlar el acceso entre las aplicaciones en tu VM de Compute Engine y otras cargas de trabajo de malla (p. ej., en el clúster de GKE).

Ejemplo: Rechazar las cargas de trabajo de Kubernetes para acceder a las VM de Compute Engine

La siguiente política de autorización rechaza una carga de trabajo de Kubernetes ratings para acceder a las cargas de trabajo de la VM de Compute Engine que entregan el servidor MySQL ratings.

kubectl apply -f - << EOF
apiVersion: security.istio.io/v1beta1
kind: AuthorizationPolicy
metadata:
  name: mysql-deny
  namespace: default
spec:
  selector:
    matchLabels:
      app: ratings
      app.kubernetes.io/name: mysql
  action: DENY
  rules:
  - from:
    - source:
        principals: ["cluster.local/ns/default/sa/bookinfo-ratings"]
EOF

Después de aplicar el ejemplo AuthorizationPolicy, deberías ver un mensaje de error Ratings service is currently unavailable en la sección de reseñas de libros en la página del producto.

Instala el agente de Cloud Monitoring

Puedes instalar el agente de Cloud Monitoring para recopilar y supervisar las métricas del sistema y de las aplicaciones de tus instancias de VM. Esto te permite supervisar métricas clave, por ejemplo, el uso de CPU y memoria en el agente.

Para obtener más información, consulta Documentación del agente de Cloud Monitoring.

Soluciona problemas

Para obtener sugerencias de solución de problemas, consulta Solución de problemas de asistencia de VM.