Criar um cluster do GKE com o Cloud Service Mesh e a CLI gcloud

Neste tutorial, você provisiona o Cloud Service Mesh gerenciado usando a API Fleet do Google Kubernetes Engine (GKE) em um novo cluster público do GKE. Neste tutorial, orientamos você sobre como:

  1. Como configurar seu projeto do Google Cloud.
  2. Como criar um cluster do GKE com o número mínimo de vCPUs exigidos pelo Cloud Service Mesh.
  3. Registrar o cluster do GKE na frota do seu projeto.
  4. Provisionar o Cloud Service Mesh gerenciado no cluster usando a API Fleet.
  5. Como implantar um gateway de entrada para expor o aplicativo
  6. A implantação de um aplicativo de amostra para que você possa visualizar dados de telemetria na Painéis do Cloud Service Mesh no console do Google Cloud.
  7. Como expor e acessar o aplicativo de amostra.

API Fleet

Neste guia, pressupomos que você esteja familiarizado com as frotas, que são agrupamentos lógicos de clusters do GKE e outros recursos que podem ser gerenciados em conjunto. Uma frota é um conceito do GKE, não um conceito do Kubernetes. O registro de um cluster em uma frota permite provisionar Cloud Service Mesh nesse cluster usando a comando gcloud container fleet mesh update. O uso das frotas é ativado pela API Fleet (gkehub.googleapis.com), que é ativada quando você inicia este tutorial.

Custos

Neste documento, você usará 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 estar qualificados para uma avaliação gratuita.

Ao concluir este guia de início rápido, exclua o cluster para evitar o faturamento contínuo. Para mais informações, consulte Limpeza.

Antes de começar

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

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

  4. Enable the GKE, Fleet (GKE Hub), and Cloud Service Mesh APIs.

    Enable the APIs

  5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  6. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

  7. Enable the GKE, Fleet (GKE Hub), and Cloud Service Mesh APIs.

    Enable the APIs

  8. Anote o ID do projeto.

Instale as ferramentas necessárias

Execute a ferramenta no Cloud Shell ou na sua máquina local. Todas as ferramentas necessárias são pré-instaladas no Cloud Shell.

Cloud Shell

O Cloud Shell provisiona uma máquina virtual (VM) g1-small do Compute Engine que executa um sistema operacional Linux baseado em Debian. Veja abaixo as vantagens de usar o Cloud Shell:

  • O Cloud Shell inclui gcloud, kubectl, git e as outras ferramentas de linha de comando que você precisa.

  • O diretório $HOME do Cloud Shell tem 5 GB de espaço de armazenamento permanente.

  • É possível escolher os editores de texto:

    • Editor de código, que você acessa clicando em na parte superior da janela do Cloud Shell.

    • Emacs, Vim ou Nano, que você acessa na linha de comando do Cloud Shell.

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

Computador local

  1. Verifique se você tem as seguintes ferramentas instaladas:

  2. Faça a autenticação com a Google Cloud CLI:

    gcloud auth login --project PROJECT_ID
    
  3. Atualize os componentes:

    gcloud components update
    

Criar um cluster do GKE

  1. Execute o comando a seguir para criar o cluster com o número mínimo de vCPUs exigidas pelo Cloud Service Mesh. No comando, substitua os marcadores pelas seguintes informações:

    • CLUSTER_NAME: o nome do cluster. O nome pode conter apenas caracteres alfanuméricos em letras minúsculas e -. Precisa começar com uma letra e terminar com um caractere alfanumérico e não pode ter mais de 40 caracteres.
    • PROJECT_ID: o ID do projeto em que o cluster será criado.
    • CLUSTER_LOCATION a zona do cluster, como us-central1-a.
    gcloud container clusters create CLUSTER_NAME \
        --project=PROJECT_ID \
        --zone=CLUSTER_LOCATION \
        --machine-type=e2-standard-4 \
        --num-nodes=2 \
        --workload-pool=PROJECT_ID.svc.id.goog
    

    A criação do cluster leva alguns minutos. Enquanto o cluster está sendo criado, o comando gcloud exibe o seguinte:

    Creating cluster CLUSTER_NAME in CLUSTER_LOCATION...working...
    

    O resultado esperado na criação bem-sucedida é semelhante ao seguinte:

    Creating cluster CLUSTER_NAME in CLUSTER_LOCATION...done.
    Created [https://container.googleapis.com/v1/projects/PROJECT_ID/zones/CLUSTER_LOCATION/clusters/CLUSTER_NAME].
    To inspect the contents of your cluster, go to: https://console.cloud.google.com/kubernetes/workload_/gcloud/CLUSTER_LOCATION/CLUSTER_NAME?project=PROJECT_ID
    kubeconfig entry generated for CLUSTER_NAME.
    NAME: CLUSTER_NAME
    LOCATION: CLUSTER_LOCATION
    MASTER_VERSION: 1.20.10-gke.1600
    MASTER_IP: 198.51.100.1
    MACHINE_TYPE: e2-standard-4
    NODE_VERSION: 1.20.10-gke.1600
    NUM_NODES: 2
    STATUS: RUNNING
    
  2. Consiga as credenciais de autenticação para interagir com o cluster.

    gcloud container clusters get-credentials CLUSTER_NAME \
        --project=PROJECT_ID \
        --zone=CLUSTER_LOCATION
    

    Saída esperada:

    Fetching cluster endpoint and auth data.
    kubeconfig entry generated for CLUSTER_NAME.
    
  3. Defina o contexto atual de kubectl como o cluster.

    kubectl config set-context CLUSTER_NAME
    

    Saída esperada:

    Context "CLUSTER_NAME" created.
    

Provisionar o Cloud Service Mesh

Se você não tiver fechado a página desde que criou o cluster, os marcadores terão os valores que foram inseridos para o comando gcloud container clusters create.

  1. Ative o Cloud Service Mesh na frota do seu projeto.

    gcloud container fleet mesh enable --project PROJECT_ID
    

    A saída é semelhante a:

    Waiting for Feature Service Mesh to be created...done.
    
  2. Registre o cluster na frota do projeto:

    gcloud container fleet memberships register CLUSTER_NAME-membership \
      --gke-cluster=CLUSTER_LOCATION/CLUSTER_NAME \
      --enable-workload-identity \
      --project PROJECT_ID
    

    A saída é semelhante a:

     Waiting for membership to be created...done.
     Finished registering to the Fleet.
    
  3. Provisione o Cloud Service Mesh gerenciado no cluster usando a API Fleet:

    gcloud container fleet mesh update \
      --management automatic \
      --memberships CLUSTER_NAME-membership \
      --project PROJECT_ID
    

    A saída é semelhante a:

    Waiting for Feature Service Mesh to be updated...done.
    
  4. Verifique se o Cloud Service Mesh gerenciado foi ativado para o cluster e se ele está pronto para uso:

    gcloud container fleet mesh describe --project PROJECT_ID
    

    Pode levar cerca de 10 minutos para o Cloud Service Mesh ser provisionado e ser prontos para uso no cluster. Se você vir controlPlaneManagement.state: DISABLED ou controlPlaneManagement.state: PROVISIONING, será necessário executar novamente o comando anterior em intervalos de alguns minutos até ver controlPlaneManagement.state: ACTIVE.

    A resposta é semelhante a:

    createTime: '2022-07-06T01:05:39.110120474Z'
    membershipSpecs:
      projects/123456789123/locations/global/memberships/your-cluster-membership:
        mesh:
          management: MANAGEMENT_AUTOMATIC
    membershipStates:
      projects/123456789123/locations/global/memberships/your-cluster-membership:
        servicemesh:
          controlPlaneManagement:
            details:
            - code: REVISION_READY
              details: 'Ready: asm-managed'
            state: ACTIVE
          dataPlaneManagement:
            details:
            - code: OK
              details: Service is running.
            state: ACTIVE
        state:
          code: OK
          description: 'Revision(s) ready for use: asm-managed.'
          updateTime: '2022-07-06T01:19:24.243993678Z'
    name: projects/your-project-id/locations/global/features/servicemesh
    resourceState:
      state: ACTIVE
    spec: {}
    state:
      state: {}
    updateTime: '2022-07-06T01:19:27.475885687Z'
    

Fazer o download do exemplo de código

Clone o repositório git que contém o código de exemplo usado neste tutorial:

   git clone https://github.com/GoogleCloudPlatform/anthos-service-mesh-packages.git

As próximas seções deste tutorial usam uma variável DIR_PATH. Defina essa variável como o caminho do repositório anthos-service-mesh-packages que você clonou (por exemplo, ./anthos-service-mesh-packages).

Implantar um gateway de entrada

O Cloud Service Mesh oferece a opção de implantar e gerenciar gateways como parte e da malha de serviço. Um gateway descreve um balanceador de carga operando na borda da malha que recebe conexões HTTP/TCP de entrada ou saída. Os gateways são proxies Envoy que fornecem um controle refinado sobre o tráfego que entra e sai da malha.

  1. Crie um namespace para o gateway de entrada, se você ainda não tiver um. Os gateways são cargas de trabalho de usuários. Como prática recomendada, não implante-os no namespace do plano de controle. Substitua GATEWAY_NAMESPACE pelo nome do namespace.

    kubectl create namespace GATEWAY_NAMESPACE
    

    Saída esperada:

    namespace/GATEWAY_NAMESPACE created
    
  2. Ativar a injeção automática no gateway. As etapas necessárias dependem do uso de rótulos de injeção padrão (por exemplo, istio-injection=enabled) ou do rótulo de revisão no namespace do gateway. A tag de revisão e o rótulo de revisão padrão são usados pelo webhook do injetor do sidecar para associar os proxies injetados a uma revisão específica do plano de controle.

    Rótulos de injeção padrão

    Aplique os rótulos de injeção padrão ao namespace.

    kubectl label namespace GATEWAY_NAMESPACE istio-injection=enabled istio.io/rev-
    

    Rótulo de revisão

    1. Use o seguinte comando para localizar o rótulo de revisão em istiod:

      kubectl get deploy -n istio-system -l app=istiod -o \
        "jsonpath={.items[*].metadata.labels['istio\.io/rev']}{'\n'}"
      

      O comando gera o rótulo de revisão que corresponde ao Versão do Cloud Service Mesh, por exemplo: asm-1187-26

    2. Aplique o identificador de revisão ao namespace. No comando a seguir, REVISION é o valor do rótulo de revisão istiod que você anotou na etapa anterior.

      kubectl label namespace GATEWAY_NAMESPACE \
        istio.io/rev=REVISION --overwrite
      

      Saída esperada:

      namespace/GATEWAY_NAMESPACE labeled
      

    Você pode ignorar a mensagem "istio.io/rev" not found na saída. Isso significa que o namespace não tinha antes o istio.io/rev, que é esperado em novas instalações do o Cloud Service Mesh ou novas implantações. Como a injeção automática falha se um namespace tem istio.io/rev e istio-injection. rótulo, todos os comandos kubectl label no Cloud Service Mesh a documentação para especificar explicitamente os dois rótulos.

    Se o namespace do gateway não estiver rotulado, os pods istio-ingressgateway falharão com um erro ImagePullBackOff quando o gateway tentar extração e a imagem auto. Essa imagem deve ser substituída pelo webhook.

  3. Faça o download do exemplo do arquivo de configuração .yaml do gateway de entrada no repositório anthos-service-mesh-packages.

  4. Aplique o exemplo de configuração do .yaml do gateway de entrada no estado em que se encontra ou modifique conforme necessário.

    kubectl apply -n GATEWAY_NAMESPACE \
      -f CONFIG_PATH/istio-ingressgateway
    

    Saída esperada:

    deployment.apps/istio-ingressgateway created
    poddisruptionbudget.policy/istio-ingressgateway created
    horizontalpodautoscaler.autoscaling/istio-ingressgateway created
    role.rbac.authorization.k8s.io/istio-ingressgateway created
    rolebinding.rbac.authorization.k8s.io/istio-ingressgateway created
    service/istio-ingressgateway created
    serviceaccount/istio-ingressgateway created
    

Saiba mais sobre as práticas recomendadas para gateways.

Implante a amostra do Online Boutique

O aplicativo de amostra Online Boutique na anthos-service-mesh-packages é modificado a partir do conjunto original de manifestos no repositório microservices-demo. Seguindo as práticas recomendadas, cada serviço é implantado em um namespace separado com uma conta de serviço exclusiva.

  1. Crie os namespaces do aplicativo:

    kubectl apply -f \
      DIR_PATH/samples/online-boutique/kubernetes-manifests/namespaces
    

    Saída esperada:

    namespace/ad created
    namespace/cart created
    namespace/checkout created
    namespace/currency created
    namespace/email created
    namespace/frontend created
    namespace/loadgenerator created
    namespace/payment created
    namespace/product-catalog created
    namespace/recommendation created
    namespace/shipping created
    
  2. Ative a injeção automática de arquivo secundário (injeção automática). O comando necessário depende se você quer usar rótulos de injeção padrão (por exemplo, istio-injection=enabled) ou o mesmo rótulo de revisão usado para anotar o namespace do gateway de entrada.

    Rótulos de injeção padrão

    Aplique os rótulos de injeção padrão ao namespace. No comando a seguir, GATEWAY_NAMESPACE é o mesmo valor usado para anotar o namespace de gateway de entrada.

    for ns in ad cart checkout currency email frontend loadgenerator payment product-catalog recommendation shipping; do
      kubectl label namespace $ns istio-injection=enabled istio.io/rev-
    done;
    

    Saída esperada:

    namespace/ad labeled
    namespace/cart labeled
    namespace/checkout labeled
    namespace/currency labeled
    namespace/email labeled
    namespace/frontend labeled
    namespace/loadgenerator labeled
    namespace/payment labeled
    namespace/product-catalog labeled
    namespace/recommendation labeled
    namespace/shipping labeled
    

    Rótulo de revisão

    Aplique o rótulo de revisão aos namespaces do aplicativo. No comando a seguir, REVISION é o mesmo valor usado para anotar o namespace de gateway de entrada.

    for ns in ad cart checkout currency email frontend loadgenerator payment product-catalog recommendation shipping; do
      kubectl label namespace $ns istio.io/rev=REVISION --overwrite
    done;
    

    Saída esperada:

    namespace/ad labeled
    namespace/cart labeled
    namespace/checkout labeled
    namespace/currency labeled
    namespace/email labeled
    namespace/frontend labeled
    namespace/loadgenerator labeled
    namespace/payment labeled
    namespace/product-catalog labeled
    namespace/recommendation labeled
    namespace/shipping labeled
    
  3. Implante o aplicativo de amostra no cluster.

    1. Crie as contas de serviço e implantações:

      kubectl apply -f \
       DIR_PATH/samples/online-boutique/kubernetes-manifests/deployments
      

      Saída esperada:

      serviceaccount/ad created
      deployment.apps/adservice created
      serviceaccount/cart created
      deployment.apps/cartservice created
      serviceaccount/checkout created
      deployment.apps/checkoutservice created
      serviceaccount/currency created
      deployment.apps/currencyservice created
      serviceaccount/email created
      deployment.apps/emailservice created
      serviceaccount/frontend created
      deployment.apps/frontend created
      serviceaccount/loadgenerator created
      deployment.apps/loadgenerator created
      serviceaccount/payment created
      deployment.apps/paymentservice created
      serviceaccount/product-catalog created
      deployment.apps/productcatalogservice created
      serviceaccount/recommendation created
      deployment.apps/recommendationservice created
      serviceaccount/shipping created
      deployment.apps/shippingservice created
      
    2. Crie os serviços:

      kubectl apply -f \
       DIR_PATH/samples/online-boutique/kubernetes-manifests/services
      

      Saída esperada:

      service/adservice created
      service/cartservice created
      service/checkoutservice created
      service/currencyservice created
      service/emailservice created
      service/frontend created
      service/frontend-external created
      service/paymentservice created
      service/productcatalogservice created
      service/recommendationservice created
      service/shippingservice created
      
    3. Crie as entradas de serviço:

      kubectl apply -f \
       DIR_PATH/samples/online-boutique/istio-manifests/allow-egress-googleapis.yaml
      

      Saída esperada:

      serviceentry.networking.istio.io/allow-egress-googleapis created
      serviceentry.networking.istio.io/allow-egress-google-metadata created
      

Como expor e acessar o aplicativo

Há várias maneiras de expor o aplicativo. Neste guia, usaremos o gateway de entrada que implantamos acima para fazer isso. Veja outras maneiras de expor o aplicativo Online Boutique na seção sobre como expor e acessar o aplicativo do guia de aplicativo de amostra "Como implantar o Online Boutique".

  1. Implantar um Gateway e um VirtualService no serviço de front-end

    kubectl apply -f \
        DIR_PATH/samples/online-boutique/istio-manifests/frontend-gateway.yaml
    

    Saída esperada:

    gateway.networking.istio.io/frontend-gateway created
    virtualservice.networking.istio.io/frontend-ingress created
    
  2. Consiga o endereço IP externo do gateway de entrada substitua os marcadores pelas seguintes informações:

    • GATEWAY_SERVICE_NAME: o nome do serviço de gateway de entrada. Se você implantou o gateway de amostra sem modificação, ele será istio-ingressgateway.
    • GATEWAY_NAMESPACE: o namespace em que você implantou o gateway de entrada:
    kubectl get service GATEWAY_SERVICE_NAME \
        -n GATEWAY_NAMESPACE
    

    A saída é semelhante a:

    NAME                   TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)                                      AGE
    istio-ingressgateway   LoadBalancer   10.19.247.233   35.239.7.64   80:31380/TCP,443:31390/TCP,31400:31400/TCP   27m

    Nesse exemplo, o endereço IP do serviço do gateway de entrada é 35.239.7.64.

  3. Acesse o aplicativo no navegador para confirmar a instalação:

    http://EXTERNAL_IP/
    

Visualize os painéis do Service Mesh

Depois de implantar as cargas de trabalho no cluster com os proxies sidecar injetado, é possível explorar as páginas do Cloud Service Mesh no console do Google Cloud para conhecer todos os recursos de observabilidade que o Cloud Service Mesh oferece. Observe que leva cerca de um ou dois minutos para que os dados de telemetria sejam exibidos no console do Google Cloud após a implantação das cargas de trabalho.

O acesso ao Cloud Service Mesh no console do Google Cloud é controlado por Identity and Access Management (IAM). Para acessar as páginas do Cloud Service Mesh, um proprietário do projeto precisa conceder aos usuários o papel de Editor ou Visualizador de projeto ou os papéis mais restritivos descritos em Como controlar o acesso ao Cloud Service Mesh no console do Google Cloud.

  1. No console do Google Cloud, acesse Cloud Service Mesh.

    Acessar o Cloud Service Mesh

  2. Selecione o projeto do Google Cloud na lista suspensa na barra de menus.

  3. Se você tiver mais de uma malha de serviço, selecione a malha na lista suspensa Service Mesh.

Para saber mais, consulte Conheça o Cloud Service Mesh no console do Google Cloud.

Limpar

Antes de limpar, se você quiser saber mais sobre o TLS mútuo, consulte Anthos Service Mesh por exemplo: mTLS.

  • Se quiser manter o cluster e remover o aplicativo de amostra do Online Boutique:

    1. Exclua os namespaces do aplicativo:

      kubectl delete -f DIR_PATH/samples/online-boutique/kubernetes-manifests/namespaces
      

      Saída esperada:

      namespace "ad" deleted
      namespace "cart" deleted
      namespace "checkout" deleted
      namespace "currency" deleted
      namespace "email" deleted
      namespace "frontend" deleted
      namespace "loadgenerator" deleted
      namespace "payment" deleted
      namespace "product-catalog" deleted
      namespace "recommendation" deleted
      namespace "shipping" deleted
      
    2. Exclua as entradas de serviço:

      kubectl delete -f DIR_PATH/samples/online-boutique/istio-manifests/allow-egress-googleapis.yaml
      

      Saída esperada:

      serviceentry.networking.istio.io "allow-egress-googleapis" deleted
      serviceentry.networking.istio.io "allow-egress-google-metadata" deleted
      
  • Se quiser evitar cobranças adicionais, exclua o cluster:

    1. Execute este comando:

      gcloud container clusters delete CLUSTER_NAME \
          --project=PROJECT_ID \
          --zone=CLUSTER_LOCATION
      
    2. No prompt Do you want to continue (Y/n)?, digite y.

      Após alguns minutos, você verá a seguinte saída:

      Deleting cluster CLUSTER_NAME...done.
      Deleted [https://container.googleapis.com/v1/projects/PROJECT_ID/zones/CLUSTER_LOCATION/clusters/CLUSTER_NAME].
      

A seguir