Guia de início rápido do Anthos Service Mesh para o GKE

Neste tutorial, instale o Anthos Service Mesh 1.12.9-asm.3 usando uma ferramenta fornecida pelo Google, asmcli, em um novo cluster do Google Kubernetes Engine (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 exigido pelo Anthos Service Mesh.
  3. Como instalar o Anthos Service Mesh com um plano de controle no cluster
  4. Como implantar um aplicativo de amostra para visualizar dados de telemetria nos painéis do Anthos Service Mesh no Console do Google Cloud.
  5. Como expor e acessar o aplicativo de amostra.

Para simplificar o guia de início rápido e não ter vários caminhos diferentes, as seguintes opções foram feitas:

  • Como ativar a autoridade de certificação do Anthos Service Mesh (CA Mesh)
  • Como implantar um gateway de entrada para expor o aplicativo

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 Kubernetes Engine API.

    Enable the API

  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 Kubernetes Engine API.

    Enable the API

  8. Anote o ID do projeto.

O Anthos Service Mesh requer outras APIs, mas o asmcli as ativa para você. Para manter os custos de faturamento baixos, o script asmcli não ativa a API GKE Enterprise. Há algumas pequenas diferenças no console do Google Cloud quando a API GKE Enterprise está ativada. Para saber mais sobre essas diferenças, consulte Diferenças na interface do GKE Enterprise e Anthos Service Mesh.

Instale as ferramentas necessárias

É possível executar a ferramenta no Cloud Shell ou na máquina local executando o Linux. Todas as ferramentas necessárias são pré-instaladas no Cloud Shell. Observe que o macOS não é compatível porque ele vem com uma versão antiga do bash.

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, kpt 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 Linux 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
    
  4. Verifique se git está no seu caminho para que kpt possa encontrá-lo.

Crie um cluster do GKE

  1. Execute o comando a seguir para criar o cluster com o número mínimo de vCPUs exigido pelo Anthos 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.
    

Fazer o download do asmcli

Nesta seção, descrevemos como fazer o download do asmcli.

  1. Faça o download da versão que instala o Anthos Service Mesh 1.12.9 no diretório de trabalho atual:

    curl https://storage.googleapis.com/csm-artifacts/asm/asmcli_1.12 > asmcli
    

    Saída esperada:

    % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
    100  167k  100  167k    0     0   701k      0 --:--:-- --:--:-- --:--:--  701k
    
  2. Torne o script executável:

    chmod +x asmcli
    

Instale o Anthos Service Mesh

Execute o script asmcli com as opções a seguir para instalar o Anthos Service Mesh na ferramenta que você criou anteriormente. 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.

./asmcli install \
  --project_id PROJECT_ID \
  --cluster_name CLUSTER_NAME \
  --cluster_location CLUSTER_LOCATION \
  --fleet_id FLEET_PROJECT_ID \
  --output_dir DIR_PATH \
  --enable_all \
  --ca mesh_ca
  • --project_id, --cluster_name e --cluster_location especifique o ID do projeto em que o cluster está, o nome dele e a zona ou região do cluster.
  • --fleet_id O ID do projeto host da frota. Se você não incluir essa opção, o asmcli usará o projeto em que o cluster foi criado durante o registro do cluster.
  • --output_dir Inclua esta opção para especificar um diretório em que asmcli faça o download do pacote anthos-service-mesh e extraia o arquivo de instalação, que contém istioctl, amostras e manifestos. Caso contrário, asmcli fará o download dos arquivos para um diretório tmp. É possível especificar um caminho relativo ou um caminho completo. A variável de ambiente $PWD não funciona aqui.
  • --enable_all Permite que o script:
    • Conceder as permissões necessárias do IAM.
    • Ative as APIs do Google necessárias.
    • Defina um rótulo no cluster que identifique a malha.
    • Registre o cluster na frota se ele ainda não estiver registrado.

    A ferramenta asmcli pode levar alguns minutos para ser concluído. A ferramenta gera mensagens informativas para que você possa acompanhar o andamento.

    Resultado esperado na instalação bem-sucedida:

    asmcli: Successfully installed ASM.
    

    Implantar um gateway de entrada

    O Anthos Service Mesh oferece a opção de implantar e gerenciar gateways como parte 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 à versão do Anthos Service Mesh, por exemplo: asm-1129-3

      2. Aplique o rótulo 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
        

        Resposta esperada:

        namespace/GATEWAY_NAMESPACE labeled
        
    3. É possível implantar a configuração de exemplo do gateway de entrada localizado no diretório samples/gateways/istio-ingressgateway/ como está ou modificá-lo conforme necessário.

      kubectl apply -n GATEWAY_NAMESPACE \
        -f DIR_PATH/samples/gateways/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 rótulo de revisão usado aqui é o mesmo usado para anotar o namespace do gateway de entrada. 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 seu cluster com os proxies sidecar injetados, acesse as páginas do Anthos Service Mesh no Console do Google Cloud para ver todos os recursos de observabilidade que o Anthos 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 Anthos Service Mesh no console do Google Cloud é controlado pelo Gerenciamento de identidade e acesso (IAM). Para acessar as páginas do Anthos 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 Anthos Service Mesh no console do Google Cloud.

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

      Acesse o Anthos 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 Como explorar o Anthos Service Mesh no Console do Google Cloud.

    Limpar

    Antes de efetuar a limpeza, se você estiver interessado em 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

    Saiba mais sobre estas situações: