Agrega clústeres de GKE a Anthos Service Mesh

En esta guía, se explica cómo unir dos clústeres en una sola Anthos Service Mesh mediante la CA de Mesh o Citadel, y habilitar el balanceo de cargas entre clústeres. Puedes ampliar con facilidad este proceso para incorporar cualquier cantidad de clústeres en la malla.

Usa configuración de Anthos Service Mesh de varios clústeres puede resolver varias situaciones empresariales fundamentales, como el escalamiento, la ubicación y el aislamiento. Para obtener más información, consulta Casos de uso de varios clústeres. Además, debes optimizar las aplicaciones para aprovechar la malla de servicios al máximo. Si deseas obtener más información, consulta Prepara una aplicación para Anthos Service Mesh.

Requisitos previos

En esta guía, se da por hecho que tienes dos o más clústeres de GKE de Google Cloud que cumplen los siguientes requisitos:

  • Anthos Service Mesh versión 1.6.8 o posterior instalada en los clústeres.
  • Si unes clústeres que no están en el mismo proyecto, deben instalarse mediante el perfil asm-gcp-multiproject y deben estar juntos en una configuración de VPC compartida. en la misma red. Además, te recomendamos que tengas un proyecto para alojar la VPC compartida y dos proyectos de servicio a fin de crear clústeres. Para obtener más información, consulta Configura clústeres con VPC compartida.
  • Si usas la CA de Citadel, usa la misma CA raíz personalizada para ambos clústeres.
  • Si Anthos Service Mesh está compilada en clústeres privados, te recomendamos crear una sola subred en la misma VPC, de lo contrario, debes asegurarte de lo siguiente:
    1. Los planos de control pueden alcanzar los planos de control del clúster privado remoto a través de las IP privadas del clúster.
    2. Puedes agregar los rangos de IP de los planos de control de llamadas a las redes autorizadas de los clústeres privados. Para obtener más información, consulta Configura el descubrimiento de extremos entre clústeres privados.

Configura variables de proyecto y clúster

  1. Establece una carpeta de trabajo para mayor comodidad. Esta es la carpeta en la que descargaste y extrajiste los archivos de Anthos Service Mesh en el paso previo, Prepárate para instalar Anthos Service Mesh.

    export PROJECT_DIR=YOUR_WORKING_FOLDER
  2. Crea una variable de contexto para cada clúster. El contexto es una string construida a partir de los ID del proyecto del clúster, los nombres de los clústeres y las ubicaciones. Para los valores de ubicación, usa la ubicación del clúster, por ejemplo, us-west2-a. En este ejemplo, una malla ya contiene un clúster y le agregas otro clúster más:

    export CTX_1=gke_CLUSTER_1_PROJECT_ID_CLUSTER_1_LOCATION_CLUSTER_1_NAME
    export CTX_2=gke_CLUSTER_2_PROJECT_ID_CLUSTER_2_LOCATION_CLUSTER_2_NAME

Configura la detección de extremos entre clústeres

Configura el descubrimiento de extremos para el balanceo de cargas entre clústeres mediante los siguientes comandos. En este paso, se realizan las siguientes tareas:

  • El comando istioctl crea un secreto que otorga acceso al servidor de la API de Kube a un clúster.
  • El comando kubectl aplica el secreto a otro clúster para que el segundo clúster pueda leer los extremos del servicio del primero.
istioctl x create-remote-secret --context=${CTX_1} --name=${CLUSTER_1_NAME} | \
  kubectl apply -f - --context=${CTX_2}
istioctl x create-remote-secret --context=${CTX_2} --name=${CLUSTER_2_NAME} | \
  kubectl apply -f - --context=${CTX_1}

Verifica tu implementación

En esta sección, se explica cómo implementar un servicio HelloWorld de muestra en el entorno de varios clústeres para verificar que funcione el balanceo de cargas entre clústeres.

Habilita la inserción de sidecar

  1. Usa el siguiente comando para localizar el valor de la etiqueta de revisión del servicio istiod, que usarás 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-173-3-5788d57586-bljj4   1/1     Running   0          23h   app=istiod,istio.io/rev=asm-173-3,istio=istiod,pod-template-hash=5788d57586
    istiod-asm-173-3-5788d57586-vsklm   1/1     Running   1          23h   app=istiod,istio.io/rev=asm-173-3,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-173-3. Use el valor de revisión en los pasos de la siguiente sección.

Instala el servicio HelloWorld

Crea el espacio de nombres de muestra y la definición del servicio en cada clúster.

  1. Crea el espacio de nombres de muestra en cada clúster:

    kubectl create --context=${CTX_1} namespace sample
    
    kubectl create --context=${CTX_2} namespace sample
    
  2. Reemplaza la etiqueta de revisión:

    kubectl label --context=${CTX_1} namespace sample \
          istio-injection- istio.io/rev=REVISION --overwrite
    
    kubectl label --context=${CTX_2} namespace sample \
      istio-injection- istio.io/rev=REVISION --overwrite
    

    En el ejemplo anterior, REVISION es la etiqueta de revisión istiod que anotaste antes.

    Este es el resultado:

    label "istio-injection" not found.
    namespace/sample labeled
    

    Puedes ignorar a label "istio-injection" not found. de forma segura

  3. Crea el servicio HelloWorld en ambos clústeres:

    kubectl create --context=${CTX_1} \
        -f ${PROJECT_DIR}/samples/helloworld/helloworld.yaml \
        -l service=helloworld -n sample
    
    kubectl create --context=${CTX_2} \
        -f ${PROJECT_DIR}/samples/helloworld/helloworld.yaml \
        -l service=helloworld -n sample
    

Implementa HelloWorld v1 y v2 en cada clúster

  1. Implementa HelloWorld v1 en CLUSTER_1 y v2 en CLUSTER_2, lo que más adelante ayudará a verificar el balanceo de cargas entre clústeres:

    kubectl create --context=${CTX_1} \
      -f ${PROJECT_DIR}/samples/helloworld/helloworld.yaml \
      -l version=v1 -n sample
    kubectl create --context=${CTX_2} \
      -f ${PROJECT_DIR}/samples/helloworld/helloworld.yaml \
      -l version=v2 -n sample
  2. Ejecuta los siguientes comandos para verificar que HelloWorld v1 y v2 se estén ejecutando. Verifica que el resultado sea similar al siguiente:

    kubectl get pod --context=${CTX_1} -n sample
    NAME                            READY     STATUS    RESTARTS   AGE
    helloworld-v1-86f77cd7bd-cpxhv  2/2       Running   0          40s
    kubectl get pod --context=${CTX_2} -n sample
    NAME                            READY     STATUS    RESTARTS   AGE
    helloworld-v2-758dd55874-6x4t8  2/2       Running   0          40s

Implementa el servicio de suspensión

  1. Implementa el servicio Sleep en ambos clústeres. En este Pod, se genera tráfico de red artificial con fines de demostración:

    for CTX in ${CTX_1} ${CTX_2}
      do
        kubectl apply --context=${CTX} \
          -f ${PROJECT_DIR}/samples/sleep/sleep.yaml -n sample
      done
  2. Espera a que se inicie el servicio Sleep en cada clúster. Verifica que el resultado sea similar al siguiente:

    kubectl get pod --context=${CTX_1} -n sample -l app=sleep
    NAME                             READY   STATUS    RESTARTS   AGE
    sleep-754684654f-n6bzf           2/2     Running   0          5s
    kubectl get pod --context=${CTX_2} -n sample -l app=sleep
    NAME                             READY   STATUS    RESTARTS   AGE
    sleep-754684654f-dzl9j           2/2     Running   0          5s

Verifica el balanceo de cargas entre clústeres

Llama al servicio HelloWorld varias veces y observa el resultado para verificar respuestas alternativas de v1 y v2:

  1. Llama al servicio HelloWorld:

    kubectl exec --context="${CTX_1}" -n sample -c sleep \
        "$(kubectl get pod --context="${CTX_1}" -n sample -l \
        app=sleep -o jsonpath='{.items[0].metadata.name}')" \
        -- curl -sS helloworld.sample:5000/hello
    

    El resultado es similar al que se muestra:

    Hello version: v2, instance: helloworld-v2-758dd55874-6x4t8
    Hello version: v1, instance: helloworld-v1-86f77cd7bd-cpxhv
    ...
  2. Vuelve a llamar al servicio HelloWorld:

    kubectl exec --context="${CTX_2}" -n sample -c sleep \
        "$(kubectl get pod --context="${CTX_2}" -n sample -l \
        app=sleep -o jsonpath='{.items[0].metadata.name}')" \
        -- curl -sS helloworld.sample:5000/hello
    

    El resultado es similar al que se muestra:

    Hello version: v2, instance: helloworld-v2-758dd55874-6x4t8
    Hello version: v1, instance: helloworld-v1-86f77cd7bd-cpxhv
    ...

Felicitaciones, ya verificaste el funcionamiento de Anthos Service Mesh de varios clústeres con balanceo de cargas.

Limpia el servicio HelloWorld

Cuando termines de verificar el balanceo de cargas, quita los servicios HelloWorld y Sleep del clúster.

kubectl delete ns sample --context ${CTX_1}
kubectl delete ns sample --context ${CTX_2}