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 seleccionarWorkloadGroup
y tener tráfico de ruta ASM para la instancia de VM de una manera similar aPod
. 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.
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.
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
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
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 aasm_vm
.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
Usa
gcloud
para configurar tu herramienta dekubectl
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:
Habilita el registro automático de VM: Esto se logra mediante la configuración de las variables
PILOT_ENABLE_WORKLOAD_ENTRY_AUTOREGISTRATION
yPILOT_ENABLE_CROSS_CLUSTER_WORKLOAD_ENTRY
en verdadero. Cuando esto esté habilitado, se crearán nuevas instancias de VM conWorkloadGroup
y se creará una nuevaWorkloadEntry
para enrutar el tráfico a la VM. Todos los planos de control de Anthos Service Mesh 1.9 instalados coninstall_asm
se incluirán de forma predeterminada.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.Instala la CRD
IdentityProvider
y registra una CRIdentityProvider
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.Registra el clúster en un Environ y habilita Workload Identity, si usas
--enable_all
o--enable_registration
en la secuencia de comandosinstall_asm
.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:
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.
Crea el espacio de nombres para las cargas de trabajo de VM si aún no existe:
kubectl create ns WORKLOAD_NAMESPACE
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
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.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. 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.
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
.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
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.
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:
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
En el resultado, en la columna
LABELS
, observa el valor de la etiqueta de revisiónistiod
de la versión nueva, que está después del prefijoistio.io/rev=
. En este ejemplo, el valor esasm-191-1
.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 deistiod
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 deistiod
esdefault
.
Agrega la etiqueta de revisión a un espacio de nombres y quita la etiqueta
istio-injection
(si existe). En el siguiente comando, cambiaREVISION
por el valor que coincide con la nueva revisión deistiod
.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 etiquetaistio-injection
antes. Debido a que la inserción automática falla si un espacio de nombres tiene tanto laistio-injection
como la etiqueta de revisión, todos los comandoskubectl label
de la documentación de Anthos Service Mesh incluyen la acción de quitar la etiquetaistio-injection
.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
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
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.
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
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
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
.
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.
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ónistiod
, que está después del prefijoistio.io/rev=
. En este ejemplo, el valor esasm-191-1
.Aplica la etiqueta de revisión al espacio de nombres
default
. En el siguiente comando,REVISION
es el valor de la etiqueta de revisiónistiod
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 etiquetaistio-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 laistio-injection
como la etiqueta de revisión, todos los comandoskubectl label
de la documentación de Anthos Service Mesh incluyen la acción de quitar la etiquetaistio-injection
.Implementa tu aplicación en el espacio de nombres predeterminado mediante
kubectl
:kubectl apply -f samples/bookinfo/platform/kube/bookinfo.yaml
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
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
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.
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
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
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
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.
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.
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
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
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
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.Para ver la página web de Bookinfo, ingresa la siguiente dirección en tu navegador:
http://EXTERNAL_IP/productpage
En la página principal de la aplicación Bookinfo, verifica que se muestren cinco estrellas de
Reviewer1
y cuatro estrellas deReviewer2
.
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.