Como fazer upgrade de um ambiente do GKE de vários clusters com o Ingress for Anthos

Neste tutorial, mostramos como fazer upgrade de um ambiente do Google Kubernetes Engine (GKE) de vários clusters usando o Ingress. Este tutorial é uma continuação do documento sobre upgrades do GKE de vários clusters usando o Ingress, que explica melhor o processo, a arquitetura e os termos. Recomendamos que você leia o documento conceitual antes deste tutorial. Este documento destina-se a administradores do Google Cloud responsáveis por manter frotas para clusters do GKE.

Recomendamos o upgrade automático dos clusters do GKE. O upgrade automático é uma maneira totalmente gerenciada de fazer com que os clusters (plano de controle e nós) sejam atualizados automaticamente em uma programação de lançamento determinada pelo Google Cloud. Isso não requer intervenção do operador. No entanto, se você quiser ter mais controle sobre como e quando fazer upgrade dos clusters, este tutorial mostra um método de fazer upgrade de vários clusters em que os apps são executados em todos os clusters. Em seguida, ele usa o Ingress para drenar um cluster por vez antes do upgrade.

Arquitetura

Neste tutorial, usamos a arquitetura a seguir. Há um total de três clusters: dois clusters (blue e green) atuam como clusters idênticos com o mesmo app implantado e um cluster (ingress-config) atua como o cluster de plano de controle que configura o Ingress. Neste tutorial, você verá como implantar um app de amostra chamado "Online Boutique" em dois clusters de aplicativos (clusters blue e green).

O app Online Boutique (em inglês) é um app de microsserviços de amostra que consiste em 10 microsserviços que simulam um app de comércio eletrônico. O app é composto de um front-end da Web (que os clientes podem acessar) e vários serviços de back-end, por exemplo, um carrinho de compras, um catálogo de produtos e serviços de recomendação que simulam um varejista eletrônico.

Arquitetura de dois clusters idênticos e um cluster de plano de controle.

Objetivos

  • Criar três clusters do GKE e registrá-los no Hub.
  • Configurar um cluster do GKE (ingress-config) como o cluster de configuração central.
  • Implantar o "Online Boutique" como um app de amostra nos outros clusters do GKE.
  • Configurar o Ingress para enviar o tráfego do cliente ao app "Online Boutique" executado em ambos os clusters do aplicativo.
  • Configurar um gerador de carga para o app "Online Boutique" e configurar o monitoramento.
  • Remover (drenar) um cluster de app do Ingress de vários clusters e fazer upgrade do cluster drenado.
  • Enviar o tráfego de volta ao cluster que recebeu upgrade usando o Ingress.

Custos

Neste tutorial, usamos os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem ser qualificados para uma avaliação gratuita.

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

Antes de começar

  1. Este tutorial requer a configuração do Ingress para que o seguinte esteja configurado:
    • Dois ou mais clusters com os mesmos apps, como namespaces, implantações e serviços, executados em todos os clusters.
    • A desabilitação do upgrade automático de todos os clusters.
    • Versões estáticas do GKE 1.14.10-gke.17 ou superior, ou clusters do GKE nos canais de lançamento rápidos ou regulares.
    • Os clusters nativos de VPC que usam intervalos de endereços IP de alias.
    • Ativação do balanceamento de carga HTTP (o padrão é ativado).
    • gcloud --version precisa ser 281 ou superior. As etapas de registro de cluster do GKE dependem dessa versão ou de uma superior.
  2. No Console do Cloud, na página do seletor de projetos, selecione ou crie um projeto do Cloud.

    Acessar a página do seletor de projetos

  3. Verifique se a cobrança está ativada para o seu projeto do Google Cloud. Saiba como confirmar se a cobrança está ativada para o seu projeto.

  4. No Console do Cloud, ative o Cloud Shell.

    Ativar o Cloud Shell

  5. Defina seu projeto padrão:

    export PROJECT=$(gcloud info --format='value(config.project)')
    gcloud config set project ${PROJECT}
    
  6. Ativar as APIs GKE, Hub e multiclusteringress:

    gcloud services enable container.googleapis.com gkehub.googleapis.com multiclusteringress.googleapis.com
    

Como configurar o ambiente

  1. No Cloud Shell, para clonar o repositório para conseguir os arquivos deste tutorial:

    cd ${HOME}
    git clone https://github.com/ameer00/gke-multicluster-upgrades.git
    
  2. Criar um diretório WORKDIR:

    cd gke-multicluster-upgrades
    export WORKDIR=`pwd`
    

Como criar e registrar clusters do GKE no Hub

Nesta seção, você criará três clusters do GKE e os registrará no Anthos Hub.

Criar clusters do GKE

  1. No Cloud Shell, para criar três clusters do GKE:

    gcloud container clusters create ingress-config --zone us-west1-a \
        --num-nodes=3 --enable-ip-alias --async
    gcloud container clusters create blue --zone us-west1-b --num-nodes=4 \
        --enable-ip-alias --async
    gcloud container clusters create green --zone us-west1-c --num-nodes=4 \
        --enable-ip-alias
    

    Para a finalidade deste tutorial, crie os clusters em três regiões diferentes: us-west1-a, us-west1-b e us-west1-c. Para saber mais sobre regiões, consulte Geografia e regiões.

  2. Aguarde alguns minutos até que todos os clusters sejam criados. Para verificar se eles estão sendo executados:

    gcloud container clusters list
    

    A resposta será semelhante a:

    NAME            LOCATION    MASTER_VERSION  MASTER_IP       MACHINE_TYPE   NODE_VERSION    NUM_NODES  STATUS
    ingress-config  us-west1-a  1.14.10-gke.24  35.203.165.186  n1-standard-1  1.14.10-gke.24  3          RUNNING
    blue            us-west1-b  1.14.10-gke.24  34.82.76.141    n1-standard-1  1.14.10-gke.24  4          RUNNING
    green           us-west1-c  1.14.10-gke.17  35.197.46.200   n1-standard-1  1.14.10-gke.17  4          RUNNING
    
  3. Criar um arquivo kubeconfig (em inglês) e conectar a todos os clusters para gerar entradas no arquivo kubeconfig:

    touch gke-upgrade-kubeconfig
    export KUBECONFIG=gke-upgrade-kubeconfig
    gcloud container clusters get-credentials ingress-config \
        --zone us-west1-a --project ${PROJECT}
    gcloud container clusters get-credentials blue --zone us-west1-b \
        --project ${PROJECT}
    gcloud container clusters get-credentials green --zone us-west1-c \
        --project ${PROJECT}
    

    Use o arquivo kubeconfig (em inglês) para criar a autenticação dos clusters com um usuário e um contexto para cada cluster. Depois de criar o arquivo kubeconfig, é possível alternar rapidamente o contexto entre os clusters.

  4. Verificar se você tem três clusters no arquivo kubeconfig:

    kubectl config view -ojson | jq -r '.clusters[].name'
    

    A saída é esta:

    gke_gke-multicluster-upgrades_us-west1-a_ingress-config
    gke_gke-multicluster-upgrades_us-west1-b_blue
    gke_gke-multicluster-upgrades_us-west1-c_green
    
  5. Receber contexto para os três clusters para uso posterior:

    export INGRESS_CONFIG_CLUSTER=$(kubectl config view -ojson | jq \
        -r '.clusters[].name' | grep ingress-config)
    export BLUE_CLUSTER=$(kubectl config view -ojson | jq \
        -r '.clusters[].name' | grep blue)
    export GREEN_CLUSTER=$(kubectl config view -ojson | jq \
        -r '.clusters[].name' | grep green)
    echo -e "${INGRESS_CONFIG_CLUSTER}\n${BLUE_CLUSTER}\n${GREEN_CLUSTER}"
    

    A saída é esta:

    gke_gke-multicluster-upgrades_us-west1-a_ingress-config
    gke_gke-multicluster-upgrades_us-west1-b_blue
    gke_gke-multicluster-upgrades_us-west1-c_green
    

Registrar clusters do GKE no Hub

O Hub permite operar clusters do Kubernetes em ambientes híbridos. O Hub também permite que os clusters registrados usem recursos avançados do GKE, como o Ingress. Para registrar um cluster do GKE no Hub, use uma conta de serviço do Google Cloud e conceda permissão de gerenciamento de identidade e acesso (IAM, na sigla em inglês) à essa conta.

  1. No Cloud Shell, para criar uma conta de serviço e fazer o download das credenciais dela:

    gcloud iam service-accounts create ingress-svc-acct
    gcloud projects add-iam-policy-binding ${PROJECT} \
        --member="serviceAccount:ingress-svc-acct@${PROJECT}.iam.gserviceaccount.com" \
        --role="roles/gkehub.connect"
    gcloud iam service-accounts keys \
        create ${WORKDIR}/ingress-svc-acct.json \
        --iam-account=ingress-svc-acct@${PROJECT}.iam.gserviceaccount.com
    
  2. Para ver os URIs dos clusters do GKE:

    export INGRESS_CONFIG_URI=$(gcloud container clusters list --uri | grep ingress-config)
    export BLUE_URI=$(gcloud container clusters list --uri | grep blue)
    export GREEN_URI=$(gcloud container clusters list --uri | grep green)
    echo -e "${INGRESS_CONFIG_URI}\n${BLUE_URI}\n${GREEN_URI}"
    

    A saída é esta:

    https://container.googleapis.com/v1/projects/gke-multicluster-upgrades/zones/us-west1-a/clusters/ingress-config
    https://container.googleapis.com/v1/projects/gke-multicluster-upgrades/zones/us-west1-b/clusters/blue
    https://container.googleapis.com/v1/projects/gke-multicluster-upgrades/zones/us-west1-c/clusters/green
    
  3. Registrar os três clusters no Hub:

    gcloud container hub memberships register ingress-config \
        --project=${PROJECT} \
        --gke-uri=${INGRESS_CONFIG_URI} \
        --service-account-key-file=${WORKDIR}/ingress-svc-acct.json
    
    gcloud container hub memberships register blue \
        --project=${PROJECT} \
        --gke-uri=${BLUE_URI} \
        --service-account-key-file=${WORKDIR}/ingress-svc-acct.json
    
    gcloud container hub memberships register green \
        --project=${PROJECT} \
        --gke-uri=${GREEN_URI} \
        --service-account-key-file=${WORKDIR}/ingress-svc-acct.json
    
  4. Verificar se os clusters estão registrados:

    gcloud container hub memberships list
    

    A resposta será semelhante a:

    NAME            EXTERNAL_ID
    blue            d40521d9-693f-11ea-a26c-42010a8a0010
    green           d3027ecd-693f-11ea-ad5f-42010a8a00a9
    ingress-config  bb778338-693f-11ea-a053-42010a8a016a
    
  5. Configurar o cluster ingress-config como o cluster de configuração do Ingress ativando o recurso multiclusteringress por meio do Hub:

    gcloud alpha container hub ingress enable \
        --config-membership=projects/${PROJECT}/locations/global/memberships/ingress-config
    

    O comando anterior adiciona as definições de recursos personalizados (CRDs, na sigla em inglês) (link em inglês) MulticlusterIngress e MulticlusterService ao cluster config. Esse comando leva alguns minutos para ser concluído. Aguarde antes de prosseguir para a próxima etapa.

  6. Verificar se o cluster ingress-cluster foi configurado com êxito para o Ingress:

    watch gcloud alpha container hub ingress describe
    

    Aguarde até que a saída seja semelhante a esta:

    createTime: '2020-03-18T18:13:46.530713607Z'
    
    featureState:
      details:
        code: OK
        description: Multicluster Ingress requires Anthos license enablement. Unlicensed
          usage is unrestricted for the MCI Beta API. Note that licensing will be enforced
          for use of the Generally Available MCI API.
      detailsByMembership:
        projects/960583074711/locations/global/memberships/blue:
          code: OK
        projects/960583074711/locations/global/memberships/green:
          code: OK
        projects/960583074711/locations/global/memberships/ingress-config:
          code: OK
      lifecycleState: ENABLED
    multiclusteringressFeatureSpec:
      configMembership: projects/gke-multicluster-upgrades/locations/global/memberships/ingress-config
    name:
    projects/gke-multicluster-upgrades/locations/global/features/multiclusteringress
    

    Para sair do comando watch, pressione Control+C.

Implantar o app "Online Boutique" nos clusters azul e verde

  1. No Cloud Shell, para implantar o app "Online Boutique" nos clusters blue e green:

    kubectl --context ${BLUE_CLUSTER} apply -f ${WORKDIR}/hipster-shop
    kubectl --context ${GREEN_CLUSTER} apply -f ${WORKDIR}/hipster-shop
    
  2. Aguarde alguns minutos e verifique se todos os pods nos clusters blue e green têm um status Running:

    kubectl --context ${BLUE_CLUSTER} get pods
    kubectl --context ${GREEN_CLUSTER} get pods
    

    A resposta será semelhante a:

    NAME                                     READY   STATUS    RESTARTS   AGE
    adservice-86f5dfb995-nlm5w               1/1     Running   0          10m
    cartservice-76cf9686b6-rxf7b             1/1     Running   0          10m
    checkoutservice-7766b946f5-qszvc         1/1     Running   0          10m
    currencyservice-76975c7847-vmwn7         1/1     Running   0          10m
    emailservice-c55cd96f-74rxs              1/1     Running   0          10m
    frontend-f4b7cd95-lk4k8                  1/1     Running   0          10m
    loadgenerator-6784bc5f77-bkx4c           1/1     Running   0          10m
    paymentservice-696f796545-8sjp5          1/1     Running   0          10m
    productcatalogservice-7975f8588c-blrbq   1/1     Running   0          10m
    recommendationservice-6d44459d79-xxb8w   1/1     Running   0          10m
    redis-cart-6448dcbdcc-8qcb4              1/1     Running   0          10m
    shippingservice-767f84b88c-8f26h         1/1     Running   0          10m
    

Configurar o Ingress de vários clusters

Nesta seção, você criará um Ingress de vários clusters que enviará tráfego ao front-end do app "Online Boutique" aos clusters blue e green. Use o Cloud Load Balancing para criar um balanceador de carga que usa os serviços de front-end nos clusters blue e green como back-ends. Para criar o balanceador de carga, você precisa de dois recursos: um MultiClusterIngress e um ou mais MultiClusterServices. Os objetos MultiClusterIngress e MultiClusterService são análogos de vários clusters dos recursos existentes Ingress e Service do Kubernetes usados no contexto de cluster único.

  1. No Cloud Shell, implante o recurso MulticlusterIngress no cluster ingress-config:

    kubectl --context ${INGRESS_CONFIG_CLUSTER} apply -f mci.yaml
    

    A saída é esta:

    multiclusteringress.networking.gke.io/frontend-multicluster-ingress created
    
  2. Implante o recurso MulticlusterService no cluster ingress-config:

    kubectl --context ${INGRESS_CONFIG_CLUSTER} apply -f mcs-blue-green.yaml
    

    A saída é esta:

    multiclusterservice.networking.gke.io/frontend-multicluster-svc created
    
  3. Para comparar os dois recursos, faça o seguinte:

    • Inspecione o recurso MulticlusterIngress:

      kubectl --context ${INGRESS_CONFIG_CLUSTER} get multiclusteringress -o yaml
      

      A saída é esta:

      spec:
          template:
            spec:
              backend:
                serviceName: frontend-multicluster-svc
                servicePort: 80
      

      O recurso MulticlusterIngress é semelhante ao recurso Ingress do Kubernetes, exceto pelo fato de a especificação serviceName apontar para um recurso MulticlusterService.

    • Inspecione o recurso MulticlusterService:

      kubectl --context ${INGRESS_CONFIG_CLUSTER} get multiclusterservice -o yaml
      

      A saída é esta:

      spec:
          clusters:
          - link: us-west1-b/blue
          - link: us-west1-c/green
          template:
            spec:
              ports:
              - name: web
                port: 80
                protocol: TCP
                targetPort: 8080
              selector:
                app: frontend
      

      O recurso MulticlusterService é semelhante a um recurso Service do Kubernetes, mas tem uma especificação clusters. O valor clusters é a lista de clusters registrados em que o recurso MulticlusterService foi criado.

    • Verifique se o recurso MulticlusterIngress criou um balanceador de carga com um serviço de back-end que aponta para o recurso MulticlusterService:

      watch kubectl --context ${INGRESS_CONFIG_CLUSTER} get multiclusteringress -o jsonpath="{.items[].status.VIP}"
      

      Aguarde até que a saída seja semelhante a esta:

      34.107.246.9
      

      Anote o endereço IP virtual (VIP, na sigla em inglês).

      Para sair do comando watch, pressione Control+C.

  4. Para acessar o app "Online Boutique", acesse o endereço IP virtual no navegador.

    Se uma mensagem de erro 404 for exibida, aguarde um pouco mais e atualize a página até ver o front-end do app "Online Boutique".

    Navegue pelo app e faça algumas compras de teste. Neste momento, o app "Online Boutique" foi implantado nos clusters blue e green e o recurso MulticlusterIngress está configurado para enviar tráfego aos dois clusters.

Como configurar o gerador de carga

Nesta seção, você configurará um serviço loadgenerator que gerará o tráfego de cliente ao endereço IP virtual do Cloud Load Balancing. Primeiro, o tráfego será enviado aos clusters blue e green porque o recurso MulticlusterService está configurado para enviar tráfego aos dois clusters. Mais tarde, configure o recurso MulticlusterService para enviar tráfego a um único cluster.

  1. Para ver o endereço IP virtual do Cloud Load Balancing no Cloud Shell:

    export GCLB_VIP=$(kubectl --context ${INGRESS_CONFIG_CLUSTER} get multiclusteringress -o json | jq -r '.items[].status.VIP')
    echo ${GCLB_VIP}
    

    A resposta será semelhante a:

    34.107.246.9
    
  2. Configurar o serviço loadgenerator para enviar o tráfego de cliente ao Cloud Load Balancing:

    sed -i 's/GCLB_VIP/'${GCLB_VIP}'/g' ${WORKDIR}/load-generator/loadgenerator.yaml
    
  3. Implantar o loadgenerator no cluster ingress-config:

    kubectl --context ${INGRESS_CONFIG_CLUSTER} apply -f ${WORKDIR}/load-generator
    
  4. Verificar se todos os pods loadgenerator no cluster ingress-config têm o status Running:

    kubectl --context ${INGRESS_CONFIG_CLUSTER} get pods
    

    A resposta será semelhante a:

    NAME                             READY   STATUS    RESTARTS   AGE
    loadgenerator-5498cbcb86-hqscp   1/1     Running   0          53s
    loadgenerator-5498cbcb86-m2z2z   1/1     Running   0          53s
    loadgenerator-5498cbcb86-p56qb   1/1     Running   0          53s
    

    Se algum dos pods não tiver o status Running, aguarde alguns minutos e execute o comando novamente.

Como monitorar o tráfego

Nesta seção, você verá como monitorar o tráfego ao app "Online Boutique" usando o Console do Cloud.

Na seção anterior, você configurou uma implantação loadgenerator que simula tráfego de cliente do app "Online Boutique" acessando-o pelo endereço IP virtual do Cloud Load Balancing. É possível monitorar essas métricas no Console do Cloud. Primeiro, configure o monitoramento para poder monitorar os clusters à medida que drena-os para upgrades (descrito na próxima seção).

  1. No Cloud Shell, para conseguir o nome da regra de encaminhamento do recurso frontend-multicluster-ingress MulticlusterIngress:

    export INGRESS_LB_RULE=$(gcloud compute forwarding-rules list | grep frontend-multicluster-ingress | awk '{print $4}')
    echo ${INGRESS_LB_RULE}
    

    A resposta será semelhante a:

    mci-h8zu63-default-frontend-multicluster-ingress
    
  2. Gerar o URL do app:

    echo "https://console.cloud.google.com/net-services/loadbalancing/details/http/${INGRESS_LB_RULE}?project=${PROJECT}&tab=monitoring&duration=PT1H"
    

    A resposta será semelhante a:

    https://console.cloud.google.com/net-services/loadbalancing/details/http/mci-h8zu63-default-frontend-multicluster-ingress?project=gke-multicluster-upgrades&tab=monitoring&duration=PT1H`
    
  3. Em um navegador, acesse o URL gerado pelo comando anterior. Na lista suspensa Back-end, selecione o back-end que começa com mci.

    Como selecionar o back-end.

    O tráfego ao app "Online Boutique" irá para os clusters blue e green (indicados pelas duas zonas em que estão os clusters). O gráfico de métricas da linha do tempo mostra o tráfego indo aos dois back-ends. Na coluna Back-end, os valores k8s1- indicam que o grupo de endpoints de rede (NEGs, na sigla em inglês) dos dois MulticlusterServices de front-end está em execução nos clusters blue e green.

    Gráfico de métricas da linha do tempo mostrando o tráfego indo aos dois back-ends.

Como drenar e fazer upgrade do cluster green

Nesta seção, você drenará o cluster green. Drenar um cluster significa que você o remove do pool de balanceamento de carga. Depois de drenar o cluster green, todo o tráfego do cliente destinado ao app "Online Boutique" vai para o cluster blue. É possível monitorar esse processo conforme descrito na seção anterior. Após a drenagem do cluster, é possível fazer upgrade dele. Após o upgrade, é possível colocá-lo novamente no pool de balanceamento de carga. Repita essas etapas para fazer upgrade do outro cluster (não mostrado neste tutorial).

Para drenar o cluster green, atualize o recurso MulticlusterService no cluster ingress-cluster e remova o cluster green da especificação clusters.

Drenar o cluster verde

  1. No Cloud Shell, para atualizar o recurso MulticlusterService no cluster ingress-config:

    kubectl --context ${INGRESS_CONFIG_CLUSTER} apply -f mcs-blue.yaml
    
  2. Verificar se você tem apenas o cluster blue na especificação clusters:

    kubectl --context ${INGRESS_CONFIG_CLUSTER} get multiclusterservice -o json | jq '.items[].spec.clusters'
    

    A saída é esta:

    {
    
    ```
        "link": "us-west1-b/blue"
    }
    ```
    

    Somente o cluster blue está listado na especificação clusters. Portanto, apenas o cluster blue está no pool de balanceamento de carga.

  3. É possível ver as métricas do Cloud Load Balancing no Console do Cloud. Gerar o URL:

    echo "https://console.cloud.google.com/net-services/loadbalancing/details/http/${INGRESS_LB_RULE}?project=${PROJECT}&tab=monitoring&duration=PT1H"
    
  4. Em um navegador, acesse o URL gerado pelo comando anterior.

    O gráfico mostra que apenas o cluster blue está recebendo tráfego do app "Online Boutique".

    Tráfego indo apenas ao cluster

Fazer upgrade do cluster green

Agora que o cluster green não está mais recebendo tráfego do cliente, é possível fazer upgrade dele (plano de controle e nós).

  1. No Cloud Shell, para conseguir a versão atual dos clusters:

    gcloud container clusters list
    

    A resposta será semelhante a:

    NAME            LOCATION    MASTER_VERSION  MASTER_IP       MACHINE_TYPE   NODE_VERSION    NUM_NODES  STATUS
    ingress-config  us-west1-a  1.14.10-gke.24  35.203.165.186  n1-standard-1  1.14.10-gke.24  3          RUNNING
    blue            us-west1-b  1.14.10-gke.24  34.82.76.141    n1-standard-1  1.14.10-gke.24  4          RUNNING
    green           us-west1-c  1.14.10-gke.24  35.197.46.200   n1-standard-1  1.14.10-gke.24  4          RUNNING
    
    

    As versões do cluster podem ser diferentes dependendo de quando você concluir este tutorial.

  2. Ver a lista de versões de MasterVersions disponíveis na zona:

    gcloud container get-server-config --zone us-west1-c --format=json | jq
    '.validMasterVersions'
    

    A resposta será semelhante a:

    [
      "1.15.9-gke.22",
      "1.15.9-gke.12",
      "1.15.9-gke.9",
      "1.15.9-gke.8",
      "1.15.8-gke.3",
      "1.14.10-gke.27",
      "1.14.10-gke.24",
      "1.14.10-gke.22",
      "1.14.10-gke.21",
      "1.14.10-gke.17",
      "1.13.12-gke.30"
    ]
    
  3. Ver uma lista de versões de NodeVersions disponíveis na zona:

    gcloud container get-server-config --zone us-west1-c --format=json | jq
    '.validNodeVersions[0:20]'
    

    A resposta será semelhante a:

    [
      "1.15.9-gke.22",
      "1.15.9-gke.12",
      "1.15.9-gke.9",
      "1.15.9-gke.8",
      "1.15.8-gke.3",
      "1.15.8-gke.2",
      "1.15.7-gke.23",
      "1.15.7-gke.2",
      "1.15.4-gke.22",
      "1.14.10-gke.27",
      "1.14.10-gke.24",
      "1.14.10-gke.22",
      "1.14.10-gke.21",
      "1.14.10-gke.17",
      "1.14.10-gke.0",
      "1.14.9-gke.23",
      "1.14.9-gke.2",
      "1.14.9-gke.0",
      "1.14.8-gke.33",
      "1.14.8-gke.21"
    ]
    
  4. Definir uma variável de ambiente para uma versão de MasterVersion e de NodeVersion que seja superior à versão atual do cluster green:

    export UPGRADE_VERSION="1.16.13-gke.401"
    

    Este tutorial usa a versão 1.16.13-gke.401. As versões do cluster podem ser diferentes, dependendo das versões disponíveis quando você concluir este tutorial. Para mais informações sobre o upgrade, consulte Como fazer upgrade de clusters e de pools de nós. Recomendamos escolher a mesma versão para todos os nós. Escolha uma das versões disponíveis na sua lista.

  5. Fazer upgrade do nó control plane para o cluster green:

    gcloud container clusters upgrade green \
        --zone us-west1-c --master --cluster-version ${UPGRADE_VERSION}
    

    Para confirmar o upgrade, pressione Y.

    Esse processo leva alguns minutos para ser concluído. Aguarde a conclusão do upgrade para continuar.

    Após a conclusão da atualização, a saída será a seguinte:

    Updated
    [https://container.googleapis.com/v1/projects/gke-multicluster-upgrades/zones/us-west1-c/clusters/green].
    
  6. Fazer upgrade dos nós no cluster green:

    gcloud container clusters upgrade green \
        --zone=us-west1-c --node-pool=default-pool \
        --cluster-version ${UPGRADE_VERSION}
    

    Para confirmar a atualização, pressione Y.

    Esse processo leva alguns minutos para ser concluído. Aguarde o término do upgrade do nó para continuar.

    Após a conclusão do upgrade, a saída será a seguinte:

    Upgrading green... Done with 4 out of 4 nodes (100.0%): 4 succeeded...done.
    Updated [https://container.googleapis.com/v1/projects/gke-multicluster-upgrades/zones/us-west1-c/clusters/green].
    
  7. Verificar se o upgrade do cluster green foi feito:

    gcloud container clusters list
    

    A resposta será semelhante a:

    NAME            LOCATION    MASTER_VERSION   MASTER_IP       MACHINE_TYPE   NODE_VERSION     NUM_NODES  STATUS
    ingress-config  us-west1-a  1.14.10-gke.24   35.203.165.186  n1-standard-1  1.14.10-gke.24   3          RUNNING
    blue            us-west1-b  1.14.10-gke.24   34.82.76.141    n1-standard-1  1.14.10-gke.24   4          RUNNING
    green           us-west1-c  1.16.13-gke.401  35.197.46.200   n1-standard-1  1.16.13-gke.401  4          RUNNING
    

Adicionar o cluster green ao pool de balanceamento de carga

Nesta seção, você adicionará o cluster green novamente ao pool de balanceamento de carga.

  1. No Cloud Shell, para verificar se todas as implantações do app "Online Boutique" estão em execução no cluster green antes de adicioná-lo novamente ao pool de balanceamento de carga:

    kubectl --context ${GREEN_CLUSTER} get pods
    

    A resposta será semelhante a:

    NAME                                     READY   STATUS    RESTARTS   AGE
    adservice-86f5dfb995-2b25h               1/1     Running   0          16m
    cartservice-76cf9686b6-ws7b7             1/1     Running   1          13m
    checkoutservice-7766b946f5-6fhjh         1/1     Running   0          9m50s
    currencyservice-76975c7847-rf8r7         1/1     Running   0          13m
    emailservice-c55cd96f-pht8h              1/1     Running   0          13m
    frontend-f4b7cd95-wxdsh                  1/1     Running   0          13m
    loadgenerator-6784bc5f77-6b4cd           1/1     Running   6          6m34s
    paymentservice-696f796545-9wrl7          1/1     Running   0          9m49s
    productcatalogservice-7975f8588c-kbm5k   1/1     Running   0          6m33s
    recommendationservice-6d44459d79-km8vm   1/1     Running   0          9m49s
    redis-cart-6448dcbdcc-sjg69              1/1     Running   0          13m
    shippingservice-767f84b88c-gh9m4         1/1     Running   0          9m49s
    
  2. Atualizar o recurso MutliclusterService para adicionar o cluster green novamente ao pool de balanceamento de carga:

    kubectl --context ${INGRESS_CONFIG_CLUSTER} apply -f mcs-blue-green.yaml
    
  3. Verificar se você tem os clusters blue e green na especificação dos clusters:

    kubectl --context ${INGRESS_CONFIG_CLUSTER} get multiclusterservice -o json | jq '.items[].spec.clusters'
    

    A saída é esta:

    {
        "link": "us-west1-b/blue"
    },
    {
        "link": "us-west1-c/green"
    }
    

    Os clusters blue e green agora estão na especificação clusters.

  4. As métricas no Cloud Load Balancing estão disponíveis no Console do Cloud. Gerar o URL:

    echo "https://console.cloud.google.com/net-services/loadbalancing/details/http/${INGRESS_LB_RULE}?project=${PROJECT}&tab=monitoring&duration=PT1H"
    
  5. Em um navegador, acesse o URL gerado pelo comando anterior.

    O gráfico mostra que os clusters azul e verde recebem tráfego do app "Online Boutique".

    Ambos os clusters estão recebendo tráfego.

    Parabéns! Você fez upgrade de um cluster do GKE em uma arquitetura de vários clusters usando o Ingress.

  6. Para fazer upgrade do cluster blue, repita o processo para drenar e atualizar o cluster verde, substituindo green por blue.

Limpeza

Para evitar que os recursos usados nesse tutorial sejam cobrados na conta do Google Cloud Platform:

A maneira mais fácil de eliminar o faturamento é excluir o projeto do Cloud que você criou para o tutorial. A outra opção é excluir os recursos individuais.

Excluir os clusters

  1. No Cloud Shell, cancele o registro e exclua os clusters blue e green:

    gcloud container hub memberships unregister green \
        --project=${PROJECT} \
        --gke-uri=${GREEN_URI}
    
    gcloud container clusters delete green --zone us-west1-c --quiet
    
    gcloud container hub memberships unregister blue \
        --project=${PROJECT} \
        --gke-uri=${BLUE_URI}
    
    gcloud container clusters delete blue --zone us-west1-b --quiet
    
  2. Exclua o recurso MuticlusterIngress do cluster ingress-config:

    kubectl --context ${INGRESS_CONFIG_CLUSTER} delete -f mci.yaml
    

    Esse comando exclui os recursos do Cloud Load Balancing do projeto.

  3. Cancelar o registro e excluir o cluster ingress-config:

    gcloud container hub memberships unregister ingress-config \
        --project=${PROJECT} \
        --gke-uri=${INGRESS_CONFIG_URI}
    gcloud container clusters delete ingress-config --zone us-west1-a --quiet
    
  4. Verificar se todos os clusters foram excluídos:

    gcloud container clusters list
    

    A saída é esta:

    *<null>*
    
  5. Redefinir o arquivo kubeconfig:

    unset KUBECONFIG
    
  6. Remover a pasta WORKDIR:

    cd ${HOME}
    rm -rf ${WORKDIR}
    

Exclua o projeto

  1. No Console do Cloud, acesse a página Gerenciar recursos:

    Acessar a página "Gerenciar recursos"

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

A seguir