Como oferecer suporte à migração com a expansão de malha do Istio: tutorial

Neste tutorial, mostramos como inicializar e configurar uma malha de serviço para realizar a migração recurso a recurso de um data center local (legado) para o Google Cloud Platform (GCP). O tutorial e o artigo conceitual são destinados a administradores de sistemas, desenvolvedores e engenheiros que querem usar uma malha de serviço que roteia dinamicamente o tráfego para o ambiente legado ou para o GCP.

Uma malha de serviço pode reduzir muito a complexidade do exercício de migração e do esforço de refatoração, porque ela separa as funções de rede das funções de serviço. Ela também reduz a complexidade operacional da rede, porque fornece balanceamento de carga, gerenciamento de tráfego, monitoramento e observabilidade.

O diagrama a seguir mostra como você pode usar uma malha de serviço para rotear o tráfego para microsserviços em execução no ambiente legado ou para o GCP:

Como usar uma malha de serviço para rotear o tráfego para microsserviços em execução no ambiente legado ou para o GCP

Você usará os seguintes software neste tutorial:

  • Ubuntu Server e Container-Optimized OS: sistemas operacionais usados neste tutorial
  • Docker Community Edition: plataforma para executar cargas de trabalho em contêiner
  • Docker Compose: uma ferramenta para definir e executar aplicativos do Docker
  • Helm: uma ferramenta para instalar e gerenciar o aplicativo do Kubernetes
  • Istio: uma malha de serviço de código aberto
  • Kiali: uma ferramenta para visualizar as malhas de serviço do Istio
  • Envoy: proxy secundário usado ao ingressar na malha de serviço do Istio

Objetivos

  • Inicializar um ambiente simulando o data center local.
  • Implantar cargas de trabalho de exemplo no data center local.
  • Testar as cargas de trabalho em execução no data center local.
  • Configurar o ambiente de destino no GCP.
  • Migrar a carga de trabalho do data center local para o ambiente de destino.
  • Testar as cargas de trabalho em execução no ambiente de destino.
  • Desativar o data center local.

Custos

Neste tutorial, usamos componentes faturáveis do GCP que incluem:

Use a calculadora de preços para gerar uma estimativa de custo com base no uso previsto.

Antes de começar

  1. Faça login na sua Conta do Google.

    Se você ainda não tiver uma, inscreva-se.

  2. Selecione ou crie um projeto do Google Cloud Platform.

    Acessar a página Gerenciar recursos

  3. Verifique se o faturamento foi ativado no projeto do Google Cloud Platform.

    Saiba como ativar o faturamento

  4. Ativar Compute Engine e GKE APIs.

    Ativar as APIs

Ao concluir este tutorial, exclua os recursos criados para evitar o faturamento contínuo. Para mais informações, consulte Como fazer a limpeza.

Como preparar o ambiente

A maioria das etapas deste tutorial são realizadas no Cloud Shell.

  1. Abra o Cloud Shell:

    ABRIR o Cloud Shell

  2. Altere o diretório de trabalho para o diretório $HOME.

    cd "$HOME"
    
  3. Clone o repositório do Git, que contém os scripts e os arquivos de manifesto a serem implantados, e configure o aplicativo de demonstração:

    git clone https://github.com/GoogleCloudPlatform/solutions-istio-mesh-expansion-migration
    
  4. Defina a região e a zona padrão:

    gcloud config set compute/region us-east1
    gcloud config set compute/zone us-east1-b
    
  5. Inicialize uma variável de ambiente que armazena o identificador de versão do Istio:

    export ISTIO_VERSION=1.1.1
    
  6. Faça o download e extraia o 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. Inicialize as variáveis de ambiente que armazenam o caminho onde você extraiu o Istio, o identificador de versão do Helm e o caminho em que você extraiu o Helm:

    ISTIO_PATH="$HOME"/istio-"$ISTIO_VERSION"
    HELM_VERSION=v2.13.0
    HELM_PATH="$HOME"/helm-"$HELM_VERSION"
    
  8. Faça o download e extraia o 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"
    

A carga de trabalho de exemplo

Neste tutorial, você usa o aplicativo Bookinfo, que é um aplicativo de microsserviços poliglota de quatro camadas, que mostra informações sobre livros. Esse aplicativo foi desenvolvido para ser executado no Kubernetes, mas primeiro é preciso implantá-lo em uma instância do Compute Engine usando o Docker e o Docker Compose. Com o Docker Compose, você descreve aplicativos de vários contêineres usando descritores YAML. Depois, é possível iniciar o aplicativo executando um único comando.

Embora essa carga de trabalho de exemplo já esteja em contêiner, essa abordagem também se aplica a serviços que não estão. Nesses casos, você pode adicionar uma "fase de modernização" em que você passa para contêiner os serviços que você pretende migrar.

O aplicativo Bookinfo tem quatro componentes de microsserviços:

  • productpage: chama os microsserviços details, ratings e reviews para preencher a página de informações do livro
  • details: veicula informações sobre livros
  • reviews: contém resenhas de livros
  • ratings: retorna informações de classificação do livro para acompanhar a resenha de um livro

Configurar os ambientes

A primeira etapa é configurar os ambientes necessários para este tutorial:

  • Um ambiente que simula o data center local (legado)
  • Um ambiente que simula o destino de migração

Este tutorial destina-se a ajudar você a migrar de um ambiente que não seja do GCP para o GCP, como um provedor de nuvem local ou outro provedor de nuvem. Essas migrações têm uma camada de complexidade de rede, porque você precisa configurar um canal de comunicação seguro entre o ambiente que não é do GCP e o do GCP.

Para este tutorial, os dois ambientes são executados no GCP. Isso simplifica o processo de configuração, exigindo apenas uma única fase de bootstrapping.

Provisionar o ambiente legado

Nesta seção, você configura um ambiente do GCP para emular um ambiente diferente do GCP, inicializando as instâncias do Compute Engine e implantando as cargas de trabalho a serem migradas. O diagrama a seguir mostra a arquitetura de destino do ambiente legado:

arquitetura para provisionar o ambiente legado

Crie regras de firewall

Crie regras de firewall para permitir o acesso externo aos microsserviços e ao banco de dados.

  • No Cloud Shell, crie as regras de firewall necessárias para comunicações entre nós:

    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
    

Inicializar uma conta de serviço para gerenciar instâncias do Compute Engine

Neste tutorial, você cria uma conta de serviço para gerenciar instâncias do Compute Engine. É uma prática recomendada limitar a conta de serviço apenas aos papéis e às permissões de acesso necessários para executar o aplicativo. Neste tutorial, o único papel necessário é o de leitor do Compute (roles/compute.viewer), que fornece acesso somente leitura aos recursos do Compute Engine.

  1. No Cloud Shell, inicialize uma variável de ambiente que armazene o nome da conta de serviço:

    GCE_SERVICE_ACCOUNT_NAME=istio-migration-gce
    
  2. Crie uma conta de serviço:

    gcloud iam service-accounts create "$GCE_SERVICE_ACCOUNT_NAME" --display-name="$GCE_SERVICE_ACCOUNT_NAME"
    
  3. Inicialize uma variável de ambiente para armazenar o endereço de e-mail completo da conta de serviço.

    GCE_SERVICE_ACCOUNT_EMAIL="$(gcloud iam service-accounts list \
        --format='value(email)' \
        --filter=displayName:"$GCE_SERVICE_ACCOUNT_NAME")"
    
  4. Vincule o papel compute.viewer à conta de serviço:

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

Inicializar o ambiente de execução

A próxima etapa é criar e configurar uma instância do Compute Engine para hospedar as cargas de trabalho a serem migradas.

  1. No Cloud Shell, inicialize e exporte uma variável com o nome da instância do Compute Engine:

    export GCE_INSTANCE_NAME=legacy-vm
    
  2. Crie uma instância do 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
    

    O tipo de máquina n1-standard-1 especificado nesse comando é o menor que permite executar a carga de trabalho de exemplo sem afetar o desempenho. Quando esse comando é concluído, o console mostra detalhes sobre a nova instância:

    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
    

O script de inicialização configura a instância do Compute Engine:

  • instalando o Docker;
  • instalando o Docker Compose;
  • instalando o Dnsmasq.

Implantar a carga de trabalho no ambiente legado

Neste tutorial, você implanta o aplicativo Bookinfo do Istio como a carga de trabalho a ser migrada.

  1. No Cloud Shell, copie os descritores do Docker Compose para a instância do Compute Engine:

    gcloud compute scp --recurse \
    "$HOME"/solutions-istio-mesh-expansion-migration/compose \
    "$GCE_INSTANCE_NAME":/tmp --zone=us-east1-b
    
  2. Aguarde a conclusão da instalação do 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. Inicie o aplicativo Bookinfo com o Docker Compose:

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

Testar sua implantação no ambiente legado

Você terminou de configurar a carga de trabalho de exemplo. Agora, é possível testá-la.

  1. No Cloud Shell, encontre o endereço IP externo da instância do Compute Engine que está executando a carga de trabalho de exemplo:

    gcloud compute instances describe "$GCE_INSTANCE_NAME" \
        --zone=us-east1-b \
        --format='value(networkInterfaces[0].accessConfigs[0].natIP)'
    
  2. Abra um navegador e acesse para o seguinte URL, em que [EXTERNAL_IP] é o endereço IP da etapa anterior:

    http://[EXTERNAL_IP]:9083/productpage
    

    Uma página é exibida com detalhes sobre livros e classificações relevantes:

    Detalhes sobre livros e classificações relevantes

Provisionar o ambiente de execução de destino

Nesta seção, você configura o ambiente de destino no GCP inicializando um cluster do GKE e expondo o serviço legado usando o Istio. O diagrama a seguir mostra a arquitetura de destino do ambiente de execução de destino:

Arquitetura para provisionar o ambiente de execução de destino

Inicializar uma conta de serviço para gerenciar clusters do GKE

Neste tutorial, você cria uma conta de serviço para gerenciar instâncias do Compute Engine no cluster do GKE. Os nós de cluster do GKE usam essa conta de serviço em vez da conta de serviço padrão, porque você quer conceder menos permissões do que as que a conta de serviço padrão tem.

Os papéis necessários para a conta de serviço são monitoring.viewer, monitoring.metricWriter e logging.logWriter, conforme descrito em Como aumentar a segurança do seu cluster.

  1. No Cloud Shell, inicialize uma variável de ambiente que armazene o nome da conta de serviço:

    GKE_SERVICE_ACCOUNT_NAME=istio-migration-gke
    
  2. Crie uma conta de serviço:

    gcloud iam service-accounts create "$GKE_SERVICE_ACCOUNT_NAME" \
        --display-name="$GKE_SERVICE_ACCOUNT_NAME"
    
  3. Inicialize uma variável de ambiente que armazena o nome da conta de e-mail da conta de serviço:

    GKE_SERVICE_ACCOUNT_EMAIL="$(gcloud iam service-accounts list \
        --format='value(email)' \
        --filter=displayName:"$GKE_SERVICE_ACCOUNT_NAME")"
    
  4. Conceda os papéis monitoring.viewer, monitoring.metricWriter e logging.logWriter à conta de serviço:

    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
    

Preparar o cluster do GKE

Nesta seção, você inicia o cluster do GKE, instala o Istio, expõe os serviços do Istio e conclui a configuração do cluster. O primeiro passo é criar e iniciar o cluster do GKE.

  1. No Cloud Shell, inicialize e exporte uma variável de ambiente que armazene o nome do cluster do GKE:

    export GKE_CLUSTER_NAME=istio-migration
    
  2. Crie um cluster do GKE regional com um pool de nós e um único nó em 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"
    

    Este comando cria um cluster do GKE chamado istio-migration. A execução desse comando pode levar até cinco minutos. Quando o comando é concluído, o console mostra detalhes sobre o cluster recém-criado:

    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
    

Em seguida, use o Helm para instalar o Istio no cluster.

  1. No Cloud Shell, inicialize e exporte uma variável de ambiente que armazene o nome do namespace do Istio:

    export ISTIO_NAMESPACE=istio-system
    
  2. Crie o namespace do Istio:

    kubectl apply -f "$ISTIO_PATH"/install/kubernetes/namespace.yaml
    
  3. Crie uma conta de serviço do Kubernetes para o Tiller, a parte do servidor do Helm:

    kubectl apply -f "$ISTIO_PATH"/install/kubernetes/helm/helm-service-account.yaml
    
  4. Instale o Tiller no seu cluster:

    "$HELM_PATH"/helm init --service-account tiller
    
  5. Instale o gráfico istio-init para fazer o bootstrap de todas as definições de recursos personalizados do Istio:

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

    Quando esse comando for concluído, o console mostrará um resumo dos novos objetos que foram instalados no cluster do 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. Verifique se os CRDs do Istio foram confirmados no api-server do Kubernetes:

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

    A saída esperada é 53.

  7. Instale o gráfico do 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
    

    A execução desse comando pode levar até dois minutos. Quando o comando for concluído, o console mostrará um resumo dos novos objetos que foram instalados no cluster do GKE:

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

    Uma lista dos recursos implantados segue este resumo.

Como as instâncias do Compute Engine que você quer adicionar à malha de serviço precisam ter acesso aos serviços do plano de controle do Istio (Pilot, Mixer, Citadel), é preciso expor esses serviços por meio dos serviços istio-ingressgateway e istio-ilbgateway. Você também expõe o servidor DNS do Kubernetes usando um balanceador de carga interno para que o servidor possa ser consultado para resolver nomes de serviços executados no cluster. Exponha também o Kiali para visualizar a malha de serviço.

  1. No Cloud Shell, crie o balanceador de carga interno para expor o servidor DNS do Kubernetes:

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/kube-dns-ilb.yaml
    
  2. Aguarde até que o objeto de serviço kube-dns-ilb seja atribuído a um endereço IP externo:

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

    A saída exibe um endereço 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 interromper o comando, pressione Control+C.

  3. Aguarde até que o objeto de serviço istio-ingressgateway receba um endereço IP externo:

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

    A saída exibe um endereço 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 interromper o comando, pressione Control+C.

  4. Aguarde até que o objeto de serviço istio-ilbgateway seja atribuído a um endereço IP externo:

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

    A saída exibe um endereço 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 interromper o comando, pressione Control+C.

  5. Exponha o Kiali com um Gateway e um VirtualService:

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

Configurar a expansão de malha do Istio

Nesta seção, você configura a expansão de malha do Istio para permitir que instâncias do Compute Engine ingressem na malha de serviço. A primeira tarefa é gerar os arquivos de configuração a serem implantados em cada instância do Compute Engine que você quer unir à malha.

  1. No Cloud Shell, inicialize e exporte uma variável de ambiente que armazene o nome do namespace padrão:

    export SERVICE_NAMESPACE=default
    
  2. Extraia as chaves da conta de serviço usada pelo Istio:

    "$ISTIO_PATH"/install/tools/setupMeshEx.sh machineCerts default "$SERVICE_NAMESPACE" all
    
  3. Inicialize e exporte uma variável de ambiente que armazene as opções do script de geração de configuração:

    export GCP_OPTS="--region $(gcloud config get-value compute/region 2> /dev/null)"
    
  4. Execute o script de geração de configuração do ambiente do cluster:

    "$ISTIO_PATH"/install/tools/setupMeshEx.sh generateClusterEnv "$GKE_CLUSTER_NAME"
    
  5. Execute o script de geração de configuração do DNS:

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

Em seguida, configure a instância do Compute Engine que você quer ingressar na malha.

  1. Cancele a configuração da variável GCP_OPTS para permitir que o script de inicialização escolha os padrões:

    unset GCP_OPTS
    
  2. Inicialize e exporte uma variável de ambiente que armazene o caminho para o script de configuração:

    export SETUP_ISTIO_VM_SCRIPT="$ISTIO_PATH"/install/tools/setupIstioVM.sh
    
  3. Prepare o descritor de versão do Istio para a inicialização da instância do Compute Engine:

    cp "$ISTIO_PATH"/istio.VERSION "$HOME"
    
  4. Execute o script de geração de configuração do ambiente do cluster:

    "$ISTIO_PATH"/install/tools/setupMeshEx.sh gceMachineSetup "$GCE_INSTANCE_NAME"
    
  5. Configure as portas locais que usarão o arquivo secundário do Envoy para serviços de entrada:

    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. Configure o namespace do cluster:

    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. Reinicie o Istio:

    gcloud compute ssh "$GCE_INSTANCE_NAME" \
        --zone=us-east1-b \
        --command='sudo systemctl restart istio'
    
  8. Verifique se o Istio foi iniciado corretamente:

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

    A saída mostra que os serviços dnsmasq, istio, istio-auth-node-agent e systemd-resolved estão carregados, ativos e em execução:

    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
    

Em seguida, adicione serviços em execução na instância do Compute Engine à malha de serviço do Istio.

  1. No Cloud Shell, crie os serviços do Kubernetes sem seletores para expor os serviços em execução na instância do Compute Engine:

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/selectorless-services.yaml
    
  2. Inicialize uma variável de ambiente que armazena o endereço IP da instância do Compute Engine em que a carga de trabalho de exemplo está sendo executada:

    GCE_INSTANCE_IP="$(gcloud compute instances describe "$GCE_INSTANCE_NAME" --format='value(networkInterfaces[].networkIP)')"
    
  3. Registre os serviços na malha:

    "$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 fim, configure os VirtualServices e as regras de roteamento correspondentes para os serviços na malha que estão atualmente em execução na instância do Compute Engine. Exponha também o serviço productpage por meio de um gateway de entrada do Istio.

  1. No Cloud Shell, implemente um objeto de Gateway para expor os serviços:

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/gateway.yaml
    
  2. Implante o VirtualService que roteie o tráfego do objeto de gateway para a instância productpage em execução no Compute Engine:

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/virtualservice-productpage-vm.yaml
    
  3. Crie o ServiceEntries para ativar a descoberta de serviços para os serviços em execução nas instâncias do Compute Engine:

    kubectl apply -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/serviceentry.yaml
    
  4. Aguarde até que o objeto de serviço istio-ingressgateway receba um endereço IP externo:

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

    Na saída, você verá um endereço 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. Confirme se um objeto de gateway bookinfo-gateway foi criado:

    kubectl get gateway --watch
    

    Na saída, você verá bookinfo-gateway na lista de objetos de gateway:

    NAME               AGE
    bookinfo-gateway   3h
    

Testar a expansão de malha do Istio

Agora que você terminou de expor a carga de trabalho de exemplo em execução na instância do Compute Engine usando o Istio, é possível testá-la:

  1. No Cloud Shell, encontre o endereço IP externo do gateway de entrada do Istio:

    kubectl get svc istio-ingressgateway -n istio-system
    
  2. Abra um navegador e acesse para o seguinte URL, em que [EXTERNAL_IP] é o endereço IP da etapa anterior:

    http://[EXTERNAL_IP]/productpage
    

    Uma página é exibida com informações sobre livros e classificações relevantes:

    livros e classificações relevantes

Visualizar a malha de serviço

Nesta seção, você usa o Kiali para ver uma representação visual da malha de serviço.

  1. No Cloud Shell, encontre o endereço IP externo do gateway de entrada do 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. Abra um navegador e acesse para o seguinte URL, em que [EXTERNAL_IP] é o endereço IP da etapa anterior:

    http://[EXTERNAL_IP]:15029/kiali/console/graph/namespaces/?  edges=requestsPercentOfTotal&graphType=versionedApp&namespaces=default&injectServiceNodes=true&duration=60&pi=5000&layout=dagre
    
  3. Na tela de login do Kiali, faça login com as seguintes credenciais:

    • Nome de usuário: admin
    • Senha: admin

    Tela de login do Kiali

  4. Execute uma solicitação várias vezes para a página principal da carga de trabalho de exemplo:

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

    Com este comando, você gera tráfego para o aplicativo Bookinfo. A saída esperada é uma lista dos códigos de retorno HTTP de cada solicitação (200 OK neste caso):

    200
    200
    200
    [...]
    

    No painel do serviço Kiali, você verá um diagrama da malha atual, com todo o tráfego roteado para os serviços em execução no Compute Engine. Todo o tráfego é encaminhado a partir de istio-ingressgateway ao serviço do Kubernetes productpage.default.svc.cluster.local, apontando para o microsserviço productpage em execução na instância do Compute Engine. Os outros microsserviços não aparecerão no gráfico (details, reviews, ratings) porque o Docker Compose está lidando com o roteamento localmente na instância do Compute Engine.

    Caso não veja o diagrama, atualize a página do painel do Kiali.

    Diagrama da malha atual

Migrar a carga de trabalho

Nesta seção, você migrará os componentes da carga de trabalho de exemplo da instância do Compute Engine para o cluster do GKE. Para cada serviço da carga de trabalho de exemplo:

  1. Implante um Pod que execute o serviço no cluster do GKE.
  2. Configure regras para dividir o tráfego entre o serviço em execução no cluster do GKE e o que está em execução na instância do Compute Engine.
  3. Migre gradualmente o tráfego do serviço em execução na instância do Compute Engine para o cluster do GKE.
  4. Interrompa o serviço em execução na instância do Compute Engine.

O diagrama a seguir mostra a arquitetura de destino do sistema para esta seção:

Arquitetura para migrar a carga de trabalho

Ativar a injeção do arquivo secundário do Istio

Cada serviço precisa de um proxy secundário do Envoy em execução para se unir à malha de serviço do Istio. Você pode ativar a injeção automática de arquivo secundário para evitar edições manuais na configuração dos seus pods.

  1. No Cloud Shell, pressione Control+C para interromper o comando de geração de tráfego.

  2. Habilite a injeção de arquivo secundário automática gerenciada pelo Istio no namespace do Kubernetes, onde você implantará as instâncias do serviço:

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

Implantar serviços no cluster do GKE

Nesta seção, você implanta instâncias no cluster do GKE e encaminha parte do tráfego para essas instâncias.

  1. No Cloud Shell, exclua as ServiceEntries antes de implantar outros serviços na malha. A exclusão dessas entradas impede solicitações de roteamento para instâncias que ainda não estão prontas:

    kubectl delete -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/serviceentry.yaml
    
  2. Implante pods e serviços do Kubernetes nos microsserviços productpage, details, reviews e ratings no cluster:

    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. Atualize a configuração de VirtualServices para dividir o tráfego de entrada entre as instâncias em execução na máquina do Compute Engine e as que estão em execução no cluster do 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. Crie o ServiceEntries para ativar a descoberta de serviços para os serviços em execução nas instâncias do Compute Engine:

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

A próxima tarefa é validar sua implantação híbrida inspecionando o tráfego direcionado a todas as instâncias de microsserviço nos dois ambientes (Compute Engine e GKE).

Use o Kiali para ver uma representação visual da malha de serviço:

  1. No Cloud Shell, encontre o endereço IP externo do gateway de entrada do 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. Abra um navegador e acesse para o seguinte URL, em que [EXTERNAL_IP] é o endereço IP da etapa anterior:

    http://[EXTERNAL_IP]:15029/kiali/console/graph/namespaces/?edges=requestsPercentOfTotal&graphType=versionedApp&namespaces=default&injectServiceNodes=true&duration=60&pi=5000&layout=dagre
    
  3. Na tela de login do Kiali, faça login com as seguintes credenciais, se necessário:

    • Nome de usuário: admin
    • Senha: admin
  4. Execute uma solicitação várias vezes para a página principal da carga de trabalho de exemplo:

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

    Com este comando, você gera tráfego para o aplicativo Bookinfo. A saída esperada é uma lista dos códigos de retorno HTTP de cada solicitação (200 OK neste caso):

    200
    200
    200
    [...]
    

    No painel de serviços do Kiali, você verá que o tráfego está sendo dividido quase igualmente entre as instâncias de microsserviço em execução no Compute Engine e as executadas no GKE (com o sufixo -gke na primeira parte do identificador de serviço). Isso ocorre porque você configurou as rotas no VirtualService para ter o mesmo peso.

    Caso não veja o diagrama, atualize a página do painel do Kiali.

    Painel que mostra a divisão de tráfego

Rotear o tráfego apenas para o cluster do GKE

Quando tiver certeza da implantação no cluster do GKE, você poderá atualizar Services e VirtualServices para rotear o tráfego somente para o cluster.

O diagrama a seguir mostra a arquitetura de destino do sistema para esta seção:

Rotear o tráfego apenas para o cluster do GKE

  1. No Cloud Shell, pressione Control+C para interromper o comando de geração de tráfego.

  2. Atualize Services e VirtualServices para rotear o tráfego para instâncias de microsserviço no cluster do GKE:

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

Para validar sua implantação, inspecione o tráfego direcionado a todas as instâncias de microsserviço nos dois ambientes (Compute Engine e GKE).

Use o Kiali para ver uma representação visual da malha de serviço:

  1. No Cloud Shell, encontre o endereço IP externo do gateway de entrada do 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. Abra um navegador e acesse para o seguinte URL, em que [EXTERNAL_IP] é o endereço IP da etapa anterior:

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

  3. Na tela de login do Kiali, faça login com as seguintes credenciais, se necessário:

    • Nome de usuário: admin
    • Senha: admin
  4. Execute uma solicitação várias vezes para a página principal da carga de trabalho de exemplo:

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

    Com este comando, você gera tráfego para o aplicativo Bookinfo. A saída esperada é uma lista dos códigos de retorno HTTP de cada solicitação (200 OK neste caso):

    200
    200
    200
    [...]
    

    No painel de serviços do Kiali, você verá que o tráfego está sendo roteado para instâncias de microsserviço em execução no cluster do GKE (com o sufixo -gke na primeira parte do identificador de serviço), enquanto que nenhum tráfego é roteado para as instâncias em execução no Compute Engine. Caso não veja o diagrama, atualize a página do painel do Kiali. Embora você tenha implantado duas instâncias de cada microsserviço (uma em execução na instância do Compute Engine e outra em execução no cluster do GKE), você configurou VirtualServices para rotear o tráfego somente para as instâncias de microsserviços em execução no cluster do GKE.

    Caso não veja o diagrama, atualize a página do painel do Kiali.

    Tráfego roteado para instâncias em execução apenas no cluster do GKE

Desativar o data center legado

Como todo o tráfego é roteado para o cluster do GKE, agora você pode excluir ServiceEntries dos microsserviços em execução no Compute Engine e interromper o Docker Compose.

O diagrama a seguir mostra a arquitetura de destino do sistema para esta seção:

Arquitetura de desativação do data center legado

  1. No Cloud Shell, pressione Control+C para interromper o comando de geração de tráfego.

  2. Exclua ServiceEntries antes de implantar outros serviços na malha:

    kubectl delete -f "$HOME"/solutions-istio-mesh-expansion-migration/kubernetes/bookinfo/istio/serviceentry.yaml
    
  3. Interrompa a carga de trabalho de exemplo em execução com o 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'
    

Visualizar a malha expandida: em execução somente no GKE

Nesta seção, você valida sua implantação inspecionando o tráfego direcionado a todas as instâncias de microsserviço nos dois ambientes (Compute Engine e GKE).

Use o Kiali para ver uma representação visual da malha de serviço:

  1. No Cloud Shell, encontre o endereço IP externo do gateway de entrada do 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. Abra um navegador e acesse para o seguinte URL, em que [EXTERNAL_IP] é o endereço IP da etapa anterior:

    http://[EXTERNAL_IP]:15029/kiali/console/graph/namespaces/?edges=requestsPercentOfTotal&graphType=versionedApp&namespaces=default&injectServiceNodes=true&duration=60&pi=5000&layout=dagre
    
  3. Na tela de login do Kiali, faça login com as seguintes credenciais, se necessário:

    • Nome de usuário: admin
    • Senha: admin
  4. Execute uma solicitação várias vezes para a página principal da carga de trabalho de exemplo:

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

    Com este comando, você gera tráfego para o aplicativo Bookinfo. A saída esperada é uma lista dos códigos de retorno HTTP de cada solicitação (200 OK neste caso):

    200
    200
    200
    [...]
    

    No painel de serviços do Kiali, você verá apenas serviços apontando para instâncias no cluster do GKE (com o sufixo -gke na primeira parte do identificador de serviço), enquanto que os serviços que apontam para instâncias em execução no Compute Engine não fazem mais parte da malha, já que você excluiu as ServiceEntries relacionadas.

    Se você não vir o diagrama, atualize a página do painel do Kiali.

    Como visualizar a malha expandida

Limpar

Para evitar cobranças dos recursos usados neste tutorial na conta do Google Cloud Platform:

  1. No Console do GCP, acesse a página Projetos.

    Acessar a página Projetos

  2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir delete.
  3. Na caixa de diálogo, digite o código do projeto e clique em Encerrar para excluí-lo.

A seguir

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…