Respalda tu migración con la expansión de malla de Istio: Instructivo

En este instructivo, se muestra cómo inicializar y configurar una malla de servicios para respaldar una migración de las características de un centro de datos local (heredado) a Google Cloud. El instructivo y el artículo conceptual que lo acompaña están orientados a los administradores de sistemas, los ingenieros y los desarrolladores que quieran usar una malla de servicios que enrute el tráfico de manera dinámica al entorno heredado o a Google Cloud.

Una malla de servicios puede reducir en gran medida la complejidad del ejercicio de migración y la refactorización, ya que separa las funciones de red de las funciones de servicio. También reduce la complejidad operativa de la red, porque proporciona balanceo de cargas, administración de tráfico, supervisión y observabilidad.

En el siguiente diagrama, se muestra cómo puedes usar una malla de servicios para enrutar el tráfico a los microservicios que se ejecutan en el entorno heredado o a Google Cloud:

Uso de una malla de servicios para enrutar el tráfico a los microservicios que se ejecutan en el entorno heredado o a Google Cloud

En este instructivo, usarás el siguiente software:

  • Ubuntu Server y Container-Optimized OS: Son los sistemas operativos que se usan en este instructivo.
  • Docker Community Edition: Es una plataforma para ejecutar cargas de trabajo en contenedores.
  • Docker Compose: Es una herramienta para definir y ejecutar apps de Docker.
  • Helm: Es una herramienta para instalar y administrar la app de Kubernetes.
  • Istio: Es una malla de servicios de código abierto.
  • Kiali: Es una herramienta para visualizar mallas de servicios de Istio.
  • Envoy: Es un proxy de sidecar que se usa para unirse a la malla de servicios de Istio.

Objetivos

  • Inicializar un entorno que simule el centro de datos local
  • Implementar cargas de trabajo de ejemplo en el centro de datos local
  • Probar las cargas de trabajo que se ejecutan en el centro de datos local
  • Configurar el entorno de destino en Google Cloud
  • Migrar la carga de trabajo del centro de datos local al entorno de destino
  • Probar las cargas de trabajo que se ejecutan en el entorno de destino
  • Retirar el centro de datos local

Costos

En este instructivo, se usan componentes facturables de Google Cloud, que incluyen lo siguiente:

Usa la calculadora de precios para generar una estimación de los costos según el uso previsto.

Antes de comenzar

  1. Accede a tu Cuenta de Google.

    Si todavía no tienes una cuenta, regístrate para obtener una nueva.

  2. En la página de selección de proyectos de Cloud Console, selecciona o crea un proyecto de Cloud.

    Ir a la página Selector de proyectos

  3. Comprueba que la facturación esté habilitada en tu proyecto.

    Descubre cómo puedes habilitar la facturación

  4. Habilita las API de Compute Engine and GKE.

    Habilita las API

Cuando finalices este instructivo, podrás borrar los recursos creados para evitar que se te siga facturando. Para obtener más información, consulta cómo hacer una limpieza.

Prepara tu entorno

Realizarás la mayoría de los pasos de este instructivo en Cloud Shell.

  1. Abre Cloud Shell:

    Abrir Cloud Shell

  2. Cambia el directorio de trabajo al directorio $HOME:

    cd "$HOME"
    
  3. Clona el repositorio de Git, que contiene las secuencias de comandos y los archivos de manifiesto para implementar y configurar la app de demostración:

    git clone https://github.com/GoogleCloudPlatform/solutions-istio-mesh-expansion-migration
    
  4. Establece la región y la zona predeterminadas:

    gcloud config set compute/region us-east1
    gcloud config set compute/zone us-east1-b
    
  5. Inicializa una variable de entorno que almacene el identificador de la versión de Istio:

    export ISTIO_VERSION=1.1.1
    
  6. Descarga y extrae Istio:

    wget https://github.com/istio/istio/releases/download/"$ISTIO_VERSION"/istio-"$ISTIO_VERSION"-linux.tar.gz
    tar -xvzf istio-"$ISTIO_VERSION"-linux.tar.gz
    
  7. Inicializa las variables de entorno que almacenan la ruta de acceso en la que extrajiste Istio, el identificador de versión de Helm y la ruta de acceso en la que deseas extraer Helm:

    ISTIO_PATH="$HOME"/istio-"$ISTIO_VERSION"
    HELM_VERSION=v2.13.0
    HELM_PATH="$HOME"/helm-"$HELM_VERSION"
    
  8. Descarga y extrae Helm:

    wget https://storage.googleapis.com/kubernetes-helm/helm-"$HELM_VERSION"-linux-amd64.tar.gz
    tar -xvzf helm-"$HELM_VERSION"-linux-amd64.tar.gz
    mv linux-amd64 "$HELM_PATH"
    

La carga de trabajo de ejemplo

En este instructivo, debes usar la app Bookinfo, que es una app de microservicios de programa multilenguaje de 4 niveles que muestra información sobre libros. Esta app se diseñó para ejecutarse en Kubernetes, pero primero debes implementarla en una instancia de Compute Engine mediante Docker y Docker Compose. Con Docker Compose, puedes describir apps de varios contenedores mediante descriptores YAML. Luego, puedes iniciar la app mediante la ejecución de un solo comando.

Aunque esta carga de trabajo de ejemplo ya está en contenedores, este enfoque también se aplica a los servicios que no están en contenedores. En esos casos, puedes agregar una “fase de modernización” en la que se creen contenedores para los servicios que deseas migrar.

La app Bookinfo tiene cuatro componentes de microservicios:

  • productpage: Llama a los microservicios details, ratings y reviews para propagar la página de información del libro.
  • details: Entrega información sobre libros.
  • reviews: Contiene reseñas de libros.
  • ratings: Muestra información sobre la clasificación de un libro para acompañar la reseña del mismo.

Configura los entornos

El primer paso es configurar los entornos que necesitas para este instructivo:

  • Un entorno que simula el centro de datos local (heredado)
  • Un entorno que simula el destino de la migración

En este instructivo, se tiene como objetivo ayudarte a migrar desde un entorno que no es de Google Cloud (como un proveedor local o algún otro proveedor de servicios en la nube) a Google Cloud. Estas migraciones tienen una capa de complejidad de red porque debes configurar un canal de comunicación seguro entre el entorno que no es de Google Cloud y el de Google Cloud.

Para este instructivo, ambos entornos se ejecutan en Google Cloud. Esto simplifica el proceso de configuración, ya que se requiere solo una fase de inicialización.

Aprovisiona el entorno heredado

En esta sección, debes configurar un entorno de Google Cloud a fin de emular otro entorno que no sea de Google Cloud. Para ello, debes inicializar instancias de Compute Engine y, luego, implementar las cargas de trabajo que se migrarán. En el siguiente diagrama, se muestra la arquitectura de destino del entorno heredado:

Arquitectura para aprovisionar el entorno heredado

Crea reglas de firewall

Crea reglas de firewall para permitir el acceso externo a los microservicios y a la base de datos.

  • En Cloud Shell, crea las reglas de firewall necesarias para las comunicaciones entre nodos:

    gcloud compute firewall-rules create bookinfo \
        --description="Bookinfo App rules" \
        --action=ALLOW \
        --rules=tcp:9080,tcp:9081,tcp:9082,tcp:9083,tcp:9084 \
        --target-tags=bookinfo-legacy-vm
    

Inicializa una cuenta de servicio para administrar instancias de Compute Engine

En este instructivo, debes crear una cuenta de servicio para administrar las instancias de Compute Engine. Se recomienda limitar la cuenta de servicio a solo las funciones y los permisos de acceso necesarios a fin de ejecutar la app. A los fines de este instructivo, la única función requerida para la cuenta de servicio es la función de visualizador de Compute (roles/compute.viewer). Esta función proporciona acceso de solo lectura a los recursos de Compute Engine.

  1. En Cloud Shell, inicializa una variable de entorno que almacene el nombre de la cuenta de servicio:

    GCE_SERVICE_ACCOUNT_NAME=istio-migration-gce
    
  2. Crea una cuenta de servicio:

    gcloud iam service-accounts create "$GCE_SERVICE_ACCOUNT_NAME" --display-name="$GCE_SERVICE_ACCOUNT_NAME"
    
  3. Inicializa una variable de entorno que almacene la dirección de correo electrónico completa de la cuenta de servicio:

    GCE_SERVICE_ACCOUNT_EMAIL="$(gcloud iam service-accounts list \
        --format='value(email)' \
        --filter=displayName:"$GCE_SERVICE_ACCOUNT_NAME")"
    
  4. Vincula la función compute.viewer a la cuenta de servicio:

    gcloud projects add-iam-policy-binding "$(gcloud config get-value project 2> /dev/null)" \
        --member serviceAccount:"$GCE_SERVICE_ACCOUNT_EMAIL" \
        --role roles/compute.viewer
    

Inicializa el entorno de ejecución

En el siguiente paso, debes crear y configurar una instancia de Compute Engine para alojar las cargas de trabajo que se migrarán.

  1. En Cloud Shell, inicializa y exporta una variable con el nombre de la instancia de Compute Engine:

    export GCE_INSTANCE_NAME=legacy-vm
    
  2. Crea una instancia de Compute Engine:

    gcloud compute instances create "$GCE_INSTANCE_NAME" \
        --boot-disk-device-name="$GCE_INSTANCE_NAME" \
        --boot-disk-size=10GB \
        --boot-disk-type=pd-ssd \
        --image-family=ubuntu-1804-lts \
        --image-project=ubuntu-os-cloud \
        --machine-type=n1-standard-1 \
        --metadata-from-file startup-script="$HOME"/solutions-istio-mesh-expansion-migration/gce-startup.sh \
        --scopes=storage-ro,logging-write,monitoring-write,service-control,service-management,trace \
        --service-account="$GCE_SERVICE_ACCOUNT_EMAIL" \
        --tags=bookinfo-legacy-vm
    

    El tipo de máquina n1-standard-1 especificado en este comando es el más pequeño que te permite ejecutar la carga de trabajo de ejemplo sin afectar el rendimiento. Cuando se completa este comando, en la consola se muestran detalles de la instancia nueva:

    NAME           ZONE        MACHINE_TYPE   PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP   STATUS
    legacy-vm      us-east1-b  n1-standard-1               10.142.0.38  34.73.53.145  RUNNING
    

Con la secuencia de comandos de inicio, se configura la instancia de Compute Engine mediante las siguientes acciones:

  • Instalación de Docker
  • Instalación de Docker Compose
  • Instalación de Dnsmasq

Implementa la carga de trabajo en el entorno heredado

En este instructivo, debes implementar la app de Istio Bookinfo como la carga de trabajo que se migrará.

  1. En Cloud Shell, copia los descriptores de Docker Compose en la instancia de Compute Engine:

    gcloud compute scp --recurse \
    "$HOME"/solutions-istio-mesh-expansion-migration/compose \
    "$GCE_INSTANCE_NAME":/tmp --zone=us-east1-b
    
  2. Espera a que se complete la instalación de Docker Compose:

    gcloud compute ssh "$GCE_INSTANCE_NAME" \
        --zone=us-east1-b \
        --command='while ! command -v docker-compose; do echo "Waiting for docker-compose to be installed"; sleep 5; done'
    
  3. Inicia la app de Bookinfo con Docker Compose:

    gcloud compute ssh "$GCE_INSTANCE_NAME" \
        --zone=us-east1-b \
        --command='sudo docker-compose -f /tmp/compose/bookinfo.yaml up -d'
    

Prueba la implementación en el entorno heredado

Ya terminaste de configurar la carga de trabajo de ejemplo, así que ahora puedes probarla.

  1. En Cloud Shell, busca la dirección IP externa de la instancia de Compute Engine que ejecuta la carga de trabajo de ejemplo:

    gcloud compute instances describe "$GCE_INSTANCE_NAME" \
        --zone=us-east1-b \
        --format='value(networkInterfaces[0].accessConfigs[0].natIP)'
    
  2. Abre un navegador y dirígete a la siguiente URL, en la que [EXTERNAL_IP] es la dirección IP del paso anterior:

    http://[EXTERNAL_IP]:9083/productpage
    

    Se muestra una página con detalles sobre libros y calificaciones relevantes:

    Detalles sobre libros y calificaciones relevantes

Aprovisiona el entorno de ejecución de destino

En esta sección, debes configurar el entorno de destino en Google Cloud mediante la inicialización de un clúster de GKE y la exposición del servicio heredado por medio de Istio. En el siguiente diagrama, se muestra la arquitectura de destino del entorno de ejecución de destino:

Arquitectura para aprovisionar el entorno de ejecución de destino

Inicializa una cuenta de servicio para administrar clústeres de GKE

En este instructivo, debes crear una cuenta de servicio para administrar las instancias de Compute Engine en el clúster de GKE. Los nodos del clúster de GKE usan esta cuenta de servicio en lugar de la cuenta de servicio predeterminada, ya que deseas otorgar menos permisos que los que se le otorgan a la cuenta de servicio predeterminada.

Las funciones que se requieren para la cuenta de servicio son monitoring.viewer, monitoring.metricWriter y logging.logWriter, como se describe en Endurece la seguridad de tu clúster.

  1. En Cloud Shell, inicializa una variable de entorno que almacene el nombre de la cuenta de servicio:

    GKE_SERVICE_ACCOUNT_NAME=istio-migration-gke
    
  2. Crea una cuenta de servicio:

    gcloud iam service-accounts create "$GKE_SERVICE_ACCOUNT_NAME" \
        --display-name="$GKE_SERVICE_ACCOUNT_NAME"
    
  3. Inicializa una variable de entorno que almacene el nombre de la cuenta de correo electrónico de la cuenta de servicio:

    GKE_SERVICE_ACCOUNT_EMAIL="$(gcloud iam service-accounts list \
        --format='value(email)' \
        --filter=displayName:"$GKE_SERVICE_ACCOUNT_NAME")"
    
  4. Otorga las funciones monitoring.viewer, monitoring.metricWriter y logging.logWriter a la cuenta de servicio:

    gcloud projects add-iam-policy-binding \
        "$(gcloud config get-value project 2> /dev/null)" \
        --member serviceAccount:"$GKE_SERVICE_ACCOUNT_EMAIL" \
        --role roles/monitoring.viewer
    gcloud projects add-iam-policy-binding \
        "$(gcloud config get-value project 2> /dev/null)" \
        --member serviceAccount:"$GKE_SERVICE_ACCOUNT_EMAIL" \
        --role roles/monitoring.metricWriter
    gcloud projects add-iam-policy-binding \
        "$(gcloud config get-value project 2> /dev/null)" \
        --member serviceAccount:"$GKE_SERVICE_ACCOUNT_EMAIL" \
        --role roles/logging.logWriter
    

Prepara el clúster de GKE

En esta sección, debes iniciar el clúster de GKE, instalar Istio, exponer los servicios de Istio y terminar de configurar el clúster. El primer paso es crear y, luego, iniciar el clúster de GKE.

  1. En Cloud Shell, inicializa y exporta una variable de entorno que almacene el nombre del clúster de GKE:

    export GKE_CLUSTER_NAME=istio-migration
    
  2. Crea un clúster de GKE regional con un grupo de nodos y un solo nodo en cada zona:

    gcloud container clusters create "$GKE_CLUSTER_NAME" \
        --addons=HorizontalPodAutoscaling,HttpLoadBalancing \
        --enable-autoupgrade \
        --enable-network-policy \
        --enable-ip-alias \
        --machine-type=n1-standard-4 \
        --metadata disable-legacy-endpoints=true \
        --node-locations us-east1-b,us-east1-c,us-east1-d \
        --no-enable-legacy-authorization \
        --no-enable-basic-auth \
        --no-issue-client-certificate \
        --num-nodes=1 \
        --region us-east1 \
        --service-account="$GKE_SERVICE_ACCOUNT_EMAIL"
    

    Mediante este comando, se crea un clúster de GKE llamado istio-migration. La ejecución de este comando puede tomar hasta cinco minutos. Cuando se completa el comando, en la consola se muestran detalles del clúster que se acaba de crear:

    NAME             LOCATION  MASTER_VERSION  MASTER_IP      MACHINE_TYPE   NODE_VERSION  NUM_NODES  STATUS
    istio-migration  us-east1  1.11.7-gke.4    35.196.136.88  n1-standard-8  1.11.7-gke.4  3          RUNNING
    

A continuación, usa Helm para instalar Istio en el clúster.

  1. En Cloud Shell, inicializa y exporta una variable de entorno que almacene el nombre del espacio de nombres de Istio:

    export ISTIO_NAMESPACE=istio-system
    
  2. Crea el espacio de nombres de Istio:

    kubectl apply -f "$ISTIO_PATH"/install/kubernetes/namespace.yaml
    
  3. Crea una cuenta de servicio de Kubernetes para Tiller, la parte del servidor de Helm:

    kubectl apply -f "$ISTIO_PATH"/install/kubernetes/helm/helm-service-account.yaml
    
  4. Instala Tiller en tu clúster:

    "$HELM_PATH"/helm init --service-account tiller
    
  5. Instala el gráfico istio-init para iniciar todas las definiciones de recursos personalizadas de Istio:

    "$HELM_PATH"/helm install "$ISTIO_PATH"/install/kubernetes/helm/istio-init --name istio-init --namespace "$ISTIO_NAMESPACE"
    

    Cuando se completa el comando, en la consola se muestra un resumen de los objetos nuevos que se instalaron en el clúster de GKE:

    NAME:   istio-init
    LAST DEPLOYED: Wed Mar 20 11:39:12 2019
    NAMESPACE: istio-system
    STATUS: DEPLOYED
    RESOURCES:
    ==> v1/ClusterRole
    NAME                     AGE
    istio-init-istio-system  1s
    ==> v1/ClusterRoleBinding
    NAME                                        AGE
    istio-init-admin-role-binding-istio-system  1s
    ==> v1/ConfigMap
    NAME          DATA  AGE
    istio-crd-10  1     1s
    istio-crd-11  1     1s
    ==> v1/Job
    NAME               COMPLETIONS  DURATION  AGE
    istio-init-crd-10  0/1          1s        1s
    istio-init-crd-11  0/1          1s        1s
    ==> v1/Pod(related)
    NAME                     READY  STATUS             RESTARTS  AGE
    istio-init-crd-10-2s28z  0/1    ContainerCreating  0         1s
    istio-init-crd-11-28n9r  0/1    ContainerCreating  0         1s
    ==> v1/ServiceAccount
    NAME                        SECRETS  AGE
    istio-init-service-account  1        1s
    
  6. Verifica que los CRD de Istio estén confirmados en el api-server de Kubernetes:

    kubectl get crds | grep 'istio.io\|certmanager.k8s.io' | wc -l
    

    El resultado esperado es 53.

  7. Instala el gráfico de Istio:

    "$HELM_PATH"/helm install "$ISTIO_PATH"/install/kubernetes/helm/istio \
        --name istio \
        --namespace "$ISTIO_NAMESPACE" \
        --set gateways.istio-ilbgateway.enabled=true \
        --set global.meshExpansion.enabled=true \
        --set global.meshExpansion.useILB=true \
        --set grafana.enabled=true \
        --set kiali.enabled=true \
        --set kiali.createDemoSecret=true \
        --set kiali.dashboard.grafanaURL=http://grafana:3000 \
        --set prometheus.enabled=true \
        --set tracing.enabled=true
    

    La ejecución de este comando puede llevar hasta dos minutos. Cuando se completa el comando, en la consola se muestra un resumen de los objetos nuevos que se instalaron en el clúster de GKE:

    NAME:   istio
    LAST DEPLOYED: Wed Mar 20 11:43:08 2019
    NAMESPACE: istio-system
    STATUS: DEPLOYED
    RESOURCES:
    

    Luego de este resumen, se incluye una lista de los recursos implementados.

Debido a que las instancias de Compute Engine que desees agregar a la malla de servicios deben tener acceso a los servicios del plano de control de Istio (Pilot, Mixer, Citadel), debes exponer estos servicios a través de los servicios istio-ingressgateway e istio-ilbgateway. También debes exponer el servidor DNS de Kubernetes mediante un balanceador de cargas interno para que se le pueda realizar una consulta al servidor a fin de que resuelva los nombres de los servicios que se ejecutan en el clúster. Además, debes exponer Kiali para visualizar la malla de servicios.

  1. En Cloud Shell, crea el balanceador de cargas interno para exponer el servidor DNS de Kubernetes:

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/kube-dns-ilb.yaml
    
  2. Espera a que se le asigne una dirección IP externa al objeto de servicio llamado kube-dns-ilb:

    kubectl get svc kube-dns-ilb -n kube-system --watch
    

    En la salida, se muestra una dirección IP para EXTERNAL-IP:

    NAME           TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
    kube-dns-ilb   LoadBalancer   10.35.252.144   10.128.0.3    53:31054/UDP   4d
    

    Para detener el comando, presiona Control+C.

  3. Espera a que se le asigne una dirección IP externa al objeto de servicio llamado istio-ingressgateway:

    kubectl get svc istio-ingressgateway -n "$ISTIO_NAMESPACE" --watch
    

    En la salida, se muestra una dirección IP para EXTERNAL-IP:

    NAME                   TYPE           CLUSTER-IP    EXTERNAL-IP    PORT(S)                                                                                                                   AGE
    istio-ingressgateway   LoadBalancer   10.48.2.195   34.73.84.179   80:31380/TCP,443:31390/TCP,31400:31400/TCP,15011:31145/TCP,8060:30381/TCP,853:30784/TCP,15030:32124/TCP,15031:32703/TCP   4d
    

    Para detener el comando, presiona Control+C.

  4. Espera a que se le asigne una dirección IP externa al objeto de servicio llamado istio-ilbgateway:

    kubectl get svc istio-ilbgateway -n "$ISTIO_NAMESPACE" --watch
    

    En la salida, se muestra una dirección IP para EXTERNAL-IP:

    NAME               TYPE           CLUSTER-IP     EXTERNAL-IP   PORT(S)                                                         AGE
    istio-ilbgateway   LoadBalancer   10.48.14.190   10.142.0.31   15011:30805/TCP,15010:31082/TCP,8060:30953/TCP,5353:30536/TCP   2m
    

    Para detener el comando, presiona Control+C.

  5. Expón Kiali con una Gateway y un Virtual Service:

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/kiali.yaml
    

Configura la expansión de malla de Istio

En esta sección, debes configurar la expansión de malla de Istio para permitir que las instancias de Compute Engine se unan a la malla de servicios. La primera tarea es generar los archivos de configuración que se implementarán en cada instancia de Compute Engine que deseas unir a la malla.

  1. En Cloud Shell, inicializa y exporta una variable de entorno que almacene el nombre del espacio de nombres predeterminado:

    export SERVICE_NAMESPACE=default
    
  2. Extrae las claves de la cuenta de servicio que usa Istio:

    "$ISTIO_PATH"/install/tools/setupMeshEx.sh machineCerts default "$SERVICE_NAMESPACE" all
    
  3. Inicializa y exporta una variable de entorno que almacene las opciones de la secuencia de comandos de generación de la configuración:

    export GCP_OPTS="--region $(gcloud config get-value compute/region 2> /dev/null)"
    
  4. Ejecuta la secuencia de comandos de generación de la configuración del entorno del clúster:

    "$ISTIO_PATH"/install/tools/setupMeshEx.sh generateClusterEnv "$GKE_CLUSTER_NAME"
    
  5. Ejecuta la secuencia de comandos de generación de la configuración de DNS:

    "$HOME"/solutions-istio-mesh-expansion-migration/gce-mesh-expansion-setup.sh
    

A continuación, configura la instancia de Compute Engine que deseas unir a la malla.

  1. Quita la variable GCP_OPTS de la configuración para permitir que la secuencia de comandos de inicialización elija los valores predeterminados:

    unset GCP_OPTS
    
  2. Inicializa y exporta una variable de entorno que almacene la ruta de acceso de la secuencia de comandos de configuración:

    export SETUP_ISTIO_VM_SCRIPT="$ISTIO_PATH"/install/tools/setupIstioVM.sh
    
  3. Prepara el descriptor de la versión de Istio para la inicialización de la instancia de Compute Engine:

    cp "$ISTIO_PATH"/istio.VERSION "$HOME"
    
  4. Ejecuta la secuencia de comandos de generación de la configuración del entorno del clúster:

    "$ISTIO_PATH"/install/tools/setupMeshEx.sh gceMachineSetup "$GCE_INSTANCE_NAME"
    
  5. Configura los puertos locales que usarán el archivo adicional de Envoy para los servicios entrantes:

    gcloud compute ssh "$GCE_INSTANCE_NAME" \
        --zone=us-east1-b \
        --command='sudo sed -i -e "\$aISTIO_INBOUND_PORTS=9081,9082,9083,9084" /var/lib/istio/envoy/sidecar.env'
    
  6. Configura el espacio de nombres del clúster:

    gcloud compute ssh "$GCE_INSTANCE_NAME" \
        --zone=us-east1-b \
        --command='sudo sed -i -e "\$aISTIO_NAMESPACE='"$SERVICE_NAMESPACE"'" /var/lib/istio/envoy/sidecar.env'
    
  7. Reinicia Istio:

    gcloud compute ssh "$GCE_INSTANCE_NAME" \
        --zone=us-east1-b \
        --command='sudo systemctl restart istio'
    
  8. Comprueba si Istio se inició de forma correcta:

    gcloud compute ssh "$GCE_INSTANCE_NAME" \
        --zone=us-east1-b \
        --command='sudo systemctl --type=service --state=running list-units | grep "dnsmasq\|istio\|systemd-resolved"'
    

    En la salida se muestra que los servicios dnsmasq, istio, istio-auth-node-agent y systemd-resolved están cargados, activos y en ejecución:

    dnsmasq.service                  loaded active running dnsmasq - A lightweight DHCP and caching DNS server
    istio-auth-node-agent.service    loaded active running istio-auth-node-agent: The Istio auth node agent
    istio.service                    loaded active running istio-sidecar: The Istio sidecar
    systemd-resolved.service         loaded active running Network Name Resolution
    

Luego, agrega servicios que se ejecuten en la instancia de Compute Engine en la malla de servicios de Istio.

  1. En Cloud Shell, crea los servicios de Kubernetes sin selectores para exponer los servicios que se ejecutan en la instancia de Compute Engine:

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/selectorless-services.yaml
    
  2. Inicializa una variable de entorno que almacene la dirección IP de la instancia de Compute Engine en la que se ejecuta la carga de trabajo de ejemplo:

    GCE_INSTANCE_IP="$(gcloud compute instances describe "$GCE_INSTANCE_NAME" --format='value(networkInterfaces[].networkIP)')"
    
  3. Registra los servicios en la malla:

    "$ISTIO_PATH"/bin/istioctl register details "$GCE_INSTANCE_IP" http:9082 -n "$SERVICE_NAMESPACE"
    "$ISTIO_PATH"/bin/istioctl register productpage "$GCE_INSTANCE_IP" http:9083 -n "$SERVICE_NAMESPACE"
    "$ISTIO_PATH"/bin/istioctl register ratings "$GCE_INSTANCE_IP" http:9081 -n "$SERVICE_NAMESPACE"
    "$ISTIO_PATH"/bin/istioctl register reviews "$GCE_INSTANCE_IP" http:9084 -n "$SERVICE_NAMESPACE"
    

Por último, configura VirtualServices y las reglas de enrutamiento correspondientes para los servicios de la malla que se encuentran en ejecución en la instancia de Compute Engine. También debes exponer el servicio productpage a través de una puerta de enlace de entrada de Istio.

  1. En Cloud Shell, implementa un objeto Gateway para exponer servicios:

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/gateway.yaml
    
  2. Implementa el VirtualService que enruta el tráfico desde el objeto Gateway hacia la instancia productpage que se ejecuta en Compute Engine:

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/virtualservice-productpage-vm.yaml
    
  3. Crea las ServiceEntries a fin de habilitar el descubrimiento de servicios para los servicios que se ejecutan en las instancias de Compute Engine:

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/serviceentry.yaml
    
  4. Espera a que se le asigne una dirección IP externa al objeto Service llamado istio-ingressgateway:

    kubectl get svc istio-ingressgateway -n istio-system --watch
    

    En la salida, deberías ver una dirección IP para EXTERNAL-IP:

    NAME                   TYPE           CLUSTER-IP    EXTERNAL-IP    PORT(S)                                                                                                                   AGE
    istio-ingressgateway   LoadBalancer   10.48.2.195   34.73.84.179   80:31380/TCP,443:31390/TCP,31400:31400/TCP,15011:31145/TCP,8060:30381/TCP,853:30784/TCP,15030:32124/TCP,15031:32703/TCP   4d
    
  5. Confirma que se creó un objeto de puerta de enlace llamado bookinfo-gateway:

    kubectl get gateway --watch
    

    En la salida, deberías ver la bookinfo-gateway en la lista de objetos de puerta de enlace:

    NAME               AGE
    bookinfo-gateway   3h
    

Prueba la expansión de malla de Istio

Ahora que terminaste de exponer la carga de trabajo de ejemplo que se ejecuta en la instancia de Compute Engine mediante Istio, puedes probarla:

  1. En Cloud Shell, busca la dirección IP externa de la puerta de enlace de entrada de Istio:

    kubectl get svc istio-ingressgateway -n istio-system
    
  2. Abre un navegador y dirígete a la siguiente URL, en la que [EXTERNAL_IP] es la dirección IP del paso anterior:

    http://[EXTERNAL_IP]/productpage
    

    Se muestra una página con información sobre libros y calificaciones relevantes:

    Libros y calificaciones relevantes

Visualiza la malla de servicios

En esta sección, debes usar Kiali para ver una representación visual de la malla de servicios.

  1. En Cloud Shell, busca la dirección IP externa de la puerta de enlace de entrada de Istio:

    kubectl get svc istio-ingressgateway -n istio-system
        EXTERNAL_IP="$(kubectl get svc istio-ingressgateway -n istio-system -o=jsonpath="{.status.loadBalancer.ingress[0].ip}")"
    
  2. Abre un navegador y dirígete a la siguiente URL, en la que [EXTERNAL_IP] es la dirección IP del paso anterior:

    http://[EXTERNAL_IP]:15029/kiali/console/graph/namespaces/?  edges=requestsPercentOfTotal&graphType=versionedApp&namespaces=default&injectServiceNodes=true&duration=60&pi=5000&layout=dagre
    
  3. En la pantalla de acceso de Kiali, accede con las siguientes credenciales:

    • Nombre de usuario: admin
    • Contraseña: admin

    Pantalla de acceso de Kiali

  4. Ejecuta una solicitud varias veces para la página principal de la carga de trabajo de ejemplo:

    for i in {1..10000}; do curl -s -o /dev/null -w "%{http_code}\n"  http://"$EXTERNAL_IP"/productpage; done
    

    Con este comando, generarás tráfico a la app Bookinfo. La salida esperada es una lista de los códigos de retorno HTTP de cada solicitud (200 OK en este caso):

    200
    200
    200
    [...]
    

    En el panel de servicio de Kiali, deberías ver un diagrama de la malla actual, con todo el tráfico enrutado a los servicios que se ejecutan en Compute Engine. Todo el tráfico se enruta desde istio-ingressgateway hacia el Service de Kubernetes productpage.default.svc.cluster.local, que apunta al microservicio productpage que se ejecuta en la instancia de Compute Engine. No ves los otros microservicios en el gráfico (details, reviews y ratings) porque Docker Compose controla el enrutamiento de forma local en la instancia de Compute Engine.

    Si no ves el diagrama, actualiza la página del panel de Kiali.

    Diagrama de la malla actual

Migra la carga de trabajo

En esta sección, debes migrar los componentes de la carga de trabajo de ejemplo de la instancia de Compute Engine al clúster de GKE. Para cada servicio de la carga de trabajo de ejemplo, debes hacer lo siguiente:

  1. Implementa un Pod que ejecute el servicio en el clúster de GKE.
  2. Configura reglas para dividir el tráfico entre el servicio que se ejecuta en el clúster de GKE y el que se ejecuta en la instancia de Compute Engine.
  3. Migra el tráfico de forma gradual desde el servicio que se ejecuta en la instancia de Compute Engine hacia el clúster de GKE.
  4. Detén el servicio que se ejecuta en la instancia de Compute Engine.

En el siguiente diagrama, se muestra la arquitectura de destino del sistema para esta sección:

Arquitectura para migrar la carga de trabajo

Habilita la inyección del archivo adicional de Istio

Cada servicio necesita un proxy de sidecar de Envoy que se ejecute para unirse a la malla de servicios de Istio. Puedes habilitar la inyección automática de sidecar para evitar las ediciones manuales en la configuración de los pods.

  1. En Cloud Shell, presiona Control+C para detener el comando de generación de tráfico.

  2. Habilita la inyección automática de sidecar administrada por Istio en el espacio de nombres de Kubernetes en el que implementarás instancias de servicio:

    kubectl label namespace "$SERVICE_NAMESPACE" istio-injection=enabled
    

Implementa servicios en el clúster de GKE

En esta sección, debes implementar instancias en el clúster de GKE y enrutar parte del tráfico a esas instancias.

  1. En Cloud Shell, borra ServiceEntries antes de implementar otros servicios en la malla. Borrar estas entradas evita que se enruten las solicitudes a instancias que aún no están listas:

    kubectl delete -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/serviceentry.yaml
    
  2. Implementa pods y Services de Kubernetes para los microservicios productpage, details, reviews y ratings en el clúster:

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/productpage.yaml
    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/details.yaml
    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/ratings.yaml
    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/reviews.yaml
    
  3. Actualiza la configuración de VirtualServices para dividir el tráfico entrante entre las instancias que se ejecutan en la máquina de Compute Engine y las que se ejecutan en el clúster de GKE:

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/virtualservice-productpage-split.yaml
    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/virtualservice-details-split.yaml
    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/virtualservice-ratings-split.yaml
    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/virtualservice-reviews-split.yaml
    
  4. Crea las ServiceEntries a fin de habilitar el descubrimiento de servicios para los servicios que se ejecutan en las instancias de Compute Engine:

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/serviceentry.yaml
    

La siguiente tarea es validar la implementación híbrida mediante la inspección del tráfico dirigido a todas las instancias de microservicios en los dos entornos (Compute Engine y GKE).

Usa Kiali para ver una representación visual de la malla de servicios:

  1. En Cloud Shell, busca la dirección IP externa de la puerta de enlace de entrada de Istio:

    kubectl get svc istio-ingressgateway -n istio-system
    EXTERNAL_IP="$(kubectl get svc istio-ingressgateway -n istio-system -o=jsonpath="{.status.loadBalancer.ingress[0].ip}")"
    
  2. Abre un navegador y dirígete a la siguiente URL, en la que [EXTERNAL_IP] es la dirección IP del paso anterior:

    http://[EXTERNAL_IP]:15029/kiali/console/graph/namespaces/?edges=requestsPercentOfTotal&graphType=versionedApp&namespaces=default&injectServiceNodes=true&duration=60&pi=5000&layout=dagre
    
  3. En la pantalla de acceso de Kiali, accede con las siguientes credenciales, de ser necesario:

    • Nombre de usuario: admin
    • Contraseña: admin
  4. Ejecuta una solicitud varias veces para la página principal de la carga de trabajo de ejemplo:

    for i in {1..10000}; do curl -s -o /dev/null -w "%{http_code}\n"  http://"$EXTERNAL_IP"/productpage; done
    

    Con este comando, generarás tráfico a la app Bookinfo. La salida esperada es una lista de los códigos de retorno HTTP de cada solicitud (200 OK en este caso):

    200
    200
    200
    [...]
    

    En el panel de servicio de Kiali, deberías ver que el tráfico se divide casi por igual entre las instancias de microservicios que se ejecutan en Compute Engine y las que se ejecutan en GKE (con el sufijo -gke en la primera parte del identificador de servicio). Esto se debe a que configuraste las rutas en VirtualService para que tengan el mismo peso.

    Si no ves el diagrama, actualiza la página del panel de Kiali.

    Panel que muestra la división de tráfico

Enruta el tráfico solo al clúster de GKE

Cuando estés seguro de la implementación en el clúster de GKE, puedes actualizar los objetos Services y VirtualServices para enrutar el tráfico solo al clúster.

En el siguiente diagrama, se muestra la arquitectura de destino del sistema para esta sección:

Enrutamiento del tráfico solo al clúster de GKE

  1. En Cloud Shell, presiona Control+C para detener el comando de generación de tráfico.

  2. Actualiza los Services y los VirtualServices para enrutar el tráfico a instancias de microservicios en el clúster de GKE:

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/virtualservice-gke.yaml
    

Para validar la implementación, inspecciona el tráfico dirigido a todas las instancias de microservicios en los dos entornos (Compute Engine y GKE).

Usa Kiali para ver una representación visual de la malla de servicios:

  1. En Cloud Shell, busca la dirección IP externa de la puerta de enlace de entrada de Istio:

    kubectl get svc istio-ingressgateway -n istio-system
    EXTERNAL_IP="$(kubectl get svc istio-ingressgateway -n istio-system -o=jsonpath="{.status.loadBalancer.ingress[0].ip}")"
    
  2. Abre un navegador y dirígete a la siguiente URL, en la que [EXTERNAL_IP] es la dirección IP del paso anterior:

    http://[EXTERNAL_IP]:15029/kiali/console/graph/namespaces/?edges=requestsPercentOfTotal&graphType=versionedApp&namespaces=default&injectServiceNodes=true&duration=60&pi=5000&layout=dagre

  3. En la pantalla de acceso de Kiali, accede con las siguientes credenciales, de ser necesario:

    • Nombre de usuario: admin
    • Contraseña: admin
  4. Ejecuta una solicitud para la página principal de la carga de trabajo de ejemplo varias veces:

    for i in {1..10000}; do curl -s -o /dev/null -w "%{http_code}\n"  http://"$EXTERNAL_IP"/productpage; done
    

    Con este comando, generarás tráfico a la app Bookinfo. La salida esperada es una lista de los códigos de retorno HTTP de cada solicitud (200 OK en este caso):

    200
    200
    200
    [...]
    

    En el panel de servicio de Kiali, deberías ver que el tráfico se enruta a las instancias de microservicios que se ejecutan en el clúster de GKE (con el sufijo -gke en la primera parte del identificador de servicio), y que no se enruta tráfico hacia las instancias que se ejecutan en Compute Engine. Si no ves el diagrama, actualiza la página del panel de Kiali: Durante la implementación de las dos instancias de cada microservicio (una que se ejecuta en la instancia de Compute Engine y la otra en el clúster de GKE), configuraste VirtualServices para enrutar el tráfico solo a las instancias de microservicios que se ejecutan en el clúster de GKE.

    Si no ves el diagrama, actualiza la página del panel de Kiali.

    Tráfico enrutado solo a las instancias que se ejecutan en el clúster de GKE

Retira el centro de datos heredado

Debido a que todo el tráfico se enruta al clúster de GKE, ahora puedes borrar las ServiceEntries de los microservicios que se ejecutan en Compute Engine y detener Docker Compose.

En el siguiente diagrama, se muestra la arquitectura de destino del sistema para esta sección:

Arquitectura para retirar el centro de datos heredado

  1. En Cloud Shell, presiona Control+C para detener el comando de generación de tráfico.

  2. Borra las ServiceEntries antes de implementar otros servicios en la malla:

    kubectl delete -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/serviceentry.yaml
    
  3. Detén la carga de trabajo de ejemplo que se ejecuta mediante Docker Compose:

    gcloud compute ssh "$GCE_INSTANCE_NAME" \
        --zone=us-east1-b \
        --command='sudo docker-compose -f /tmp/compose/bookinfo.yaml down --remove-orphans -v'
    

Visualiza la malla expandida: solo en ejecución en GKE

En esta sección, debes validar la implementación mediante la inspección del tráfico dirigido a todas las instancias de microservicios en los dos entornos (Compute Engine y GKE).

Usa Kiali para ver una representación visual de la malla de servicios:

  1. En Cloud Shell, busca la dirección IP externa de la puerta de enlace de entrada de Istio:

    kubectl get svc istio-ingressgateway -n istio-system
    EXTERNAL_IP="$(kubectl get svc istio-ingressgateway -n istio-system -o=jsonpath="{.status.loadBalancer.ingress[0].ip}")"
    
  2. Abre un navegador y dirígete a la siguiente URL, en la que [EXTERNAL_IP] es la dirección IP del paso anterior:

    http://[EXTERNAL_IP]:15029/kiali/console/graph/namespaces/?edges=requestsPercentOfTotal&graphType=versionedApp&namespaces=default&injectServiceNodes=true&duration=60&pi=5000&layout=dagre
    
  3. En la pantalla de acceso de Kiali, accede con las siguientes credenciales, de ser necesario:

    • Nombre de usuario: admin
    • Contraseña: admin
  4. Ejecuta una solicitud varias veces para la página principal de la carga de trabajo de ejemplo:

    for i in {1..10000}; do curl -s -o /dev/null -w "%{http_code}\n"  http://"$EXTERNAL_IP"/productpage; done
    

    Con este comando, generarás tráfico a la app Bookinfo. La salida esperada es una lista de los códigos de retorno HTTP de cada solicitud (200 OK en este caso):

    200
    200
    200
    [...]
    

    En el panel de servicio de Kiali, solo deberías ver los servicios que apuntan a las instancias en el clúster de GKE (con el sufijo -gke en la primera parte del identificador de servicio), dado que los servicios que apuntan a las instancias que se ejecutan en Compute Engine ya no forman parte de la malla, ya que borraste las ServiceEntries relacionadas.

    Si no ves el diagrama, actualiza la página del panel de Kiali:

    Visualización de la malla expandida

Realiza una limpieza

Sigue estos pasos para evitar que se apliquen cargos a tu cuenta de Google Cloud Platform por los recursos que usaste en este instructivo:

  1. En Cloud Console, ve a la página Administrar recursos.

    Ir a la página Administrar recursos

  2. En la lista de proyectos, selecciona el proyecto que deseas borrar y haz clic en Borrar .
  3. En el cuadro de diálogo, escribe el ID del proyecto y haz clic en Cerrar para borrar el proyecto.

Próximos pasos