Como integrar o IAP com o Anthos Service Mesh

Neste tutorial, você aprende a integrar o Identity-Aware Proxy (IAP) ao Anthos Service Mesh. A integração do IAP ao Anthos Service Mesh permite acessar serviços de maneira segura com base nos princípios do BeyondCorp do Google. O IAP verifica a identidade do usuário e o contexto da solicitação para determinar se o usuário pode acessar um aplicativo ou recurso. A integração do IAP com o Anthos Service Mesh oferece as seguintes vantagens:

  • Controle total de acesso baseado no contexto das cargas de trabalho em execução no Anthos Service Mesh. É possível definir políticas de acesso detalhadas com base nos atributos da solicitação de origem, como identidade do usuário, endereço IP e tipo de dispositivo. É possível combinar políticas de acesso com restrições baseadas no nome do host e no caminho de um URL de solicitação.

  • Ativação do suporte para declarações contextuais na autorização do Anthos Service Mesh.

  • Acesso escalonável, seguro e altamente disponível ao aplicativo por meio de um balanceador de carga do Google Cloud. O balanceamento de carga de alto desempenho fornece proteção integrada contra ataques distribuídos de negação de serviço (DDoS, na sigla em inglês) e suporte para endereços IP anycast globais.

Objetivos

  • Comece a configurar:
    1. Configure seu projeto do Google Cloud para conceder as permissões e ativar as APIs do Google exigidas pelo IAP.
    2. Reserve um endereço IP estático externo e configure um nome de domínio para usar o endereço IP necessário para o balanceador de carga.
    3. Configure um novo cluster do Google Kubernetes Engine (GKE) com as opções necessárias para integrar o IAP ao Anthos Service Mesh.
    4. Instale o Anthos Service Mesh com as opções necessárias para a integração.
    5. Implante um aplicativo de amostra.
    6. Implantar o balanceador de carga.

  • Ativar o IAP

  • Ativar o suporte ao RCToken na malha de serviço

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 as tarefas descritas neste documento, é possível evitar o faturamento contínuo excluindo os recursos criados. Saiba mais em Limpeza.

Antes de começar

Requisitos

  • Você precisa ter uma licença de avaliação ou uma assinatura do Anthos. Veja mais detalhes no guia de preços do Anthos.

  • Seu cluster do GKE precisa atender aos seguintes requisitos:

  • Para serem incluídos na malha de serviço, as portas precisam ser nomeadas, e o nome precisa incluir o protocolo da porta na seguinte sintaxe: name: protocol[-suffix], em que os colchetes indicam um sufixo opcional que precisa começar com um traço. Para mais informações, Como nomear portas de serviço.

  • Se você estiver instalando o Anthos Service Mesh em um cluster particular, será necessário adicionar uma regra de firewall para abrir a porta 15017 caso queira usar a injeção automática de sidecar. Se não adicionar a regra de firewall e a injeção automática de sidecar estiver ativada, você receberá um erro ao implantar as cargas de trabalho. Saiba mais sobre como adicionar uma regra de firewall em Como adicionar regras de firewall para casos de uso específicos.

  • Se você tiver criado um perímetro de serviço na sua organização, talvez seja necessário adicionar o serviço Mesh CA ao perímetro. Saiba mais em Como adicionar o Mesh CA a um perímetro de serviço.

Como configurar o ambiente

Para instalações no Google Kubernetes Engine, siga os guias de instalação usando o Cloud Shell, uma interface de linha de comando no navegador para os recursos do Google Cloud ou no computador com Linux ou macOS:

Opção A: usar o 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 as ferramentas de linha de comando gcloud, kubectl e helm necessárias.

  • 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.

Para usar o Cloud Shell:

  1. Acesse o Console do Google Cloud.
  2. Selecione seu projeto do Google Cloud.

  3. Clique no botão Ativar Cloud Shell na parte superior da janela do console do Google Cloud.

    Console do Google Cloud Platform

    Uma sessão do Cloud Shell é aberta dentro de um novo frame na parte inferior do console do Google Cloud, e exibe um prompt de linha de comando.

    Sessão do Cloud Shell

  4. Atualize os componentes:

    gcloud components update

    O comando responde com uma saída semelhante a esta:

    ERROR: (gcloud.components.update)
You cannot perform this action because the gcloud CLI component manager
is disabled for this installation. You can run the following command
to achieve the same result for this installation:

sudo apt-get update && sudo apt-get --only-upgrade install ...

  5. Copie o comando longo e cole-o para atualizar os componentes.

  6. Instale kubectl:

    sudo apt-get install kubectl

  7. Instale kpt:

    sudo apt-get install google-cloud-sdk-kpt

Opção B: usar ferramentas de linha de comando localmente

Na máquina local, instale e inicialize a gcloud CLI.

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

    gcloud auth login

  2. Atualize os componentes:

    gcloud components update

  3. Instale kubectl:

    gcloud components install kubectl

  4. Instale kpt:

    gcloud components install kpt

Configurar o projeto

  1. Encontre o ID do projeto em que o cluster será criado:

    gcloud

    gcloud projects list

    Console

    1. No console do Google Cloud, abra a página Painel.

      Ir para a página "Painel"

    2. Clique na lista suspensa Selecionar de na parte superior da página. Na janela Selecionar de exibida, selecione seu projeto.

      O ID do projeto é exibido no card Informações do projeto do Painel.

  2. Crie uma variável de ambiente para o ID do projeto: 
    export PROJECT_ID=YOUR_PROJECT_ID
  3. Defina o ID do projeto padrão para a ferramenta de linha de comando gcloud: 
    gcloud config set project ${PROJECT_ID}
  4. Crie uma variável de ambiente para o número do projeto: 
    export PROJECT_NUMBER=$(gcloud projects describe ${PROJECT_ID} --format="value(projectNumber)")

  5. Defina os papéis necessários de gerenciamento de identidade e acesso (IAM, na sigla em inglês). Se você for um proprietário do projeto, terá todas as permissões necessárias para concluir a instalação e registrar o cluster com o ambiente. Se você não for proprietário do projeto, será necessário alguém que conceda os seguintes papéis específicos do IAM. No comando a seguir, altere GCP_EMAIL_ADDRESS para a conta que você usa para fazer login no Google Cloud. 
    gcloud projects add-iam-policy-binding ${PROJECT_ID} \
     --member user:GCP_EMAIL_ADDRESS \
     --role=roles/editor \
     --role=roles/compute.admin \
     --role=roles/container.admin \
     --role=roles/resourcemanager.projectIamAdmin \
     --role=roles/iam.serviceAccountAdmin \
     --role=roles/iam.serviceAccountKeyAdmin \
     --role=roles/gkehub.admin

    Para saber mais sobre como conceder papéis do IAM, consulte Como conceder, alterar e revogar o acesso a recursos. Para uma descrição desses papéis, consulte Permissões necessárias para instalar o Anthos Service Mesh

  6. Ative as APIs a seguir: 
    gcloud services enable \
    container.googleapis.com \
    compute.googleapis.com \
    monitoring.googleapis.com \
    logging.googleapis.com \
    cloudtrace.googleapis.com \
    meshca.googleapis.com \
    meshtelemetry.googleapis.com \
    meshconfig.googleapis.com \
    iamcredentials.googleapis.com \
    anthos.googleapis.com \
    gkeconnect.googleapis.com \
    gkehub.googleapis.com \
    cloudresourcemanager.googleapis.com \
    iap.googleapis.com

    A ativação das APIs pode levar um minuto ou mais para ser concluída. Quando as APIs estão ativadas, você vê uma saída semelhante a esta:

    Operation "operations/acf.601db672-88e6-4f98-8ceb-aa3b5725533c" finished
successfully.

Reservar um endereço IP estático e configurar o DNS

Para integrar o Identity-Aware Proxy com o Anthos Service Mesh, configure um balanceador de carga do Google Cloud HTTP(S), que requer um nome de domínio que aponte para um endereço IP estático. É possível reservar um endereço IP externo estático, que atribui o endereço ao projeto de maneira indefinida até você liberá-lo explicitamente.

  1. Reserve um endereço IP externo estático.

    gcloud compute addresses create example-static-ip --global

  2. Consiga o endereço IP estático:

    gcloud compute addresses describe example-static-ip --global

  3. No registrador de domínios, configure um nome de domínio totalmente qualificado (FQDN, na sigla em inglês) com o endereço IP estático. Normalmente, você adiciona um registro A às configurações de DNS. As etapas de configuração e a terminologia para adicionar um registro A para um FQDN variam de acordo com o registrador de domínios.

  4. Defina o nome de domínio em uma variável de ambiente:

    export DOMAIN_NAME=YOUR_DOMAIN_NAME

    Pode levar de 24 a 48 horas para que a configuração de DNS seja propagada. É possível continuar configurando tudo neste tutorial, mas você só poderá testar a configuração depois que as configurações de DNS se propagarem.

Como configurar um novo cluster do GKE

Para configurar um novo cluster, siga estas etapas:

  1. Selecione uma zona, um tipo de máquina e um canal de lançamento do GKE para o novo cluster. O tipo de máquina mínimo exigido pelo Anthos Service Mesh é n1-standard-4. Use qualquer opção de canal de lançamento.

    • Para uma lista das zonas disponíveis do GCP:

      gcloud compute zones list

    • Para ver uma lista de tipos de máquina:

      gcloud compute machine-types list | more

  2. Crie as variáveis de ambiente a seguir:

    • Defina o nome do cluster:

      export CLUSTER_NAME=YOUR_CLUSTER_NAME

      O nome do cluster precisa conter apenas caracteres alfanuméricos em letras minúsculas e "-", precisa começar com uma letra e terminar com um alfanumérico e não pode ter mais de 40 caracteres.

    • Defina CLUSTER_LOCATION como a zona do cluster:

      export CLUSTER_LOCATION=YOUR_ZONE

    • Defina o pool de carga de trabalho:

      export WORKLOAD_POOL=${PROJECT_ID}.svc.id.goog

    • Defina o ID da malha:

      export MESH_ID="proj-${PROJECT_NUMBER}"

  3. Crie o cluster com as opções exigidas pelo Anthos Service Mesh. O comando a seguir cria um cluster contendo quatro nós do tipo de máquina n1-standard-4, que tem quatro vCPUs. Esse é o tipo mínimo de máquina e o número de nós necessários para o Anthos Service Mesh. É possível especificar outro tipo de máquina, desde que ele tenha pelo menos quatro vCPUs, e também aumentar o número de nós conforme necessário para os requisitos do sistema.

    gcloud beta container clusters create ${CLUSTER_NAME} \
    --project=${PROJECT_ID} \
    --zone=${CLUSTER_LOCATION} \
    --machine-type=n1-standard-4 \
    --num-nodes=4 \
    --workload-pool=${WORKLOAD_POOL} \
    --enable-stackdriver-kubernetes \
    --subnetwork=default \
    --labels mesh_id=${MESH_ID} \
    --addons=HttpLoadBalancing \
    --release-channel=regular

    O comando clusters create inclui:

    • workload-pool=${WORKLOAD_POOL}: ativa a Identidade da carga de trabalho, que é a maneira recomendada de acessar com segurança os serviços do Google Cloud a partir de aplicativos do GKE.

    • enable-stackdriver-kubernetes: ativa o Cloud Monitoring e o Cloud Logging no GKE.

    • subnetwork=default: cria uma sub-rede padrão.

    • labels mesh_id=${MESH_ID}: define o rótulo mesh_id no cluster, necessário para que as métricas sejam exibidas no painel do Anthos Service Mesh no Console do Google Cloud.

    • O complemento HttpLoadBalancing, que ativa um controlador de balanceamento de carga HTTP (L7) para o cluster.

    • release-channel regular: registra o cluster no canal de lançamento regular, embora você possa escolher stable se precisar de maior estabilidade ou rapid se quiser testar novos (não compatíveis) recursos do GKE.

Como configurar credenciais e permissões

  1. Inicialize seu projeto para prepará-lo para instalação. Entre outras coisas, esse comando cria uma conta de serviço para permitir que os componentes do Istio, como o proxy sidecar, acessem com segurança os dados e os recursos do seu projeto: 
    curl --request POST \
  --header "Authorization: Bearer $(gcloud auth print-access-token)" \
  --data '' \
  https://meshconfig.googleapis.com/v1alpha1/projects/${PROJECT_ID}:initialize

    A resposta do comando mostra chaves vazias: {}

    Se você instalar uma nova versão do Anthos Service Mesh nesse cluster futuramente, não precisará executar novamente o comando. Mas executá-lo novamente não afetará sua instalação.

  2. Receba credenciais de autenticação para interagir com o cluster: 
    gcloud container clusters get-credentials ${CLUSTER_NAME}
  3. Conceda permissões de administrador de cluster ao usuário atual. Você precisa dessas permissões para criar as regras necessárias de controle de acesso baseado em papéis (RBAC, na sigla em inglês) para o Anthos Service Mesh: 
    kubectl create clusterrolebinding cluster-admin-binding \
  --clusterrole=cluster-admin \
  --user="$(gcloud config get-value core/account)"

    Se você vir o erro "cluster-admin-binding" already exists, poderá ignorá-lo com segurança e continuar com a vinculação atual de cluster-admin.

Como registrar o cluster

É necessário registrar o cluster com a frota do projeto para ter acesso à interface do usuário unificada no Console do Google Cloud. Uma frota fornece uma forma unificada de visualizar e gerenciar os clusters e as cargas de trabalho deles, incluindo clusters fora do Google Cloud.

Criar uma conta de serviço e um arquivo de chave do Google Cloud

Um arquivo JSON contendo credenciais de conta de serviço é necessário para registrar um cluster. Para seguir o princípio de privilégio mínimo, recomendamos que você crie uma conta de serviço distinta para cada cluster registrado.

Para criar uma conta de serviço e um arquivo de chave:

  1. Selecione um nome para a conta de serviço e crie uma variável de ambiente para ela:

    export SERVICE_ACCOUNT_NAME=SERVICE_ACCOUNT_NAME

  2. Crie a conta de serviço:

    gcloud iam service-accounts create ${SERVICE_ACCOUNT_NAME}

  3. Liste todas as contas de serviço de um projeto para confirmar se a conta de serviço foi criada:

    gcloud iam service-accounts list

  4. Vincule o papel do IAM gkehub.connect à conta de serviço:

    gcloud projects add-iam-policy-binding ${PROJECT_ID} \
   --member="serviceAccount:${SERVICE_ACCOUNT_NAME}@${PROJECT_ID}.iam.gserviceaccount.com" \
   --role="roles/gkehub.connect"

  5. Crie uma variável de ambiente para o caminho de arquivo local em que você quer salvar o arquivo JSON. Recomendamos que você nomeie o arquivo usando o nome da conta de serviço e o ID do projeto, como: /tmp/creds/${SERVICE_ACCOUNT_NAME}-${PROJECT_ID}.json

    export SERVICE_ACCOUNT_KEY_PATH=LOCAL_KEY_PATH

  6. Faça o download do arquivo JSON da chave privada da conta de serviço.

    gcloud iam service-accounts keys create ${SERVICE_ACCOUNT_KEY_PATH} \
   --iam-account=${SERVICE_ACCOUNT_NAME}@${PROJECT_ID}.iam.gserviceaccount.com

Registre o cluster

No comando a seguir, substitua MEMBERSHIP_NAME por um nome que represente de maneira exclusiva o cluster que está sendo registrado no Hub.

gcloud container hub memberships register MEMBERSHIP_NAME \
    --gke-cluster=${CLUSTER_LOCATION}/${CLUSTER_NAME} \
    --service-account-key-file=${SERVICE_ACCOUNT_KEY_PATH}

O comando responde com uma saída semelhante a esta: 

kubeconfig entry generated for CLUSTER_NAME.
Waiting for membership to be created...done.
Created a new membership [projects/PROJECT_ID/locations/global/memberships/MEMBERSHIP_NAME] for the cluster [MEMBERSHIP_NAME]
Generating the Connect Agent manifest...
Deploying the Connect Agent on cluster [MEMBERSHIP_NAME] in namespace [gke-connect]...
Deployed the Connect Agent on cluster [MEMBERSHIP_NAME] in namespace [gke-connect].
Finished registering the cluster [MEMBERSHIP_NAME] with the Hub.

Esta chave de conta de serviço é armazenada como um secret chamado creds-gcp no namespace gke-connect.

Para mais informações sobre o registro de clusters, consulte Como registrar um cluster na documentação do Connect.

Como fazer o download do arquivo de instalação

Antes de continuar, verifique se a conta de serviço do plano de dados do ASM Mesh é membro do projeto:

gcloud projects get-iam-policy ${PROJECT_ID} | grep -B 1 'roles/meshdataplane.serviceAgent'

Se o comando anterior não gerar nada, volte para a seção Definir credenciais e permissões e execute o comando curl.

    Linux

  1. Faça o download do arquivo de instalação do Anthos Service Mesh no diretório de trabalho atual: 
    curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.5.10-asm.2-linux.tar.gz
  2. Faça o download do arquivo de assinatura e use openssl para verificar a assinatura: 
    curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.5.10-asm.2-linux.tar.gz.1.sig
openssl dgst -verify - -signature istio-1.5.10-asm.2-linux.tar.gz.1.sig istio-1.5.10-asm.2-linux.tar.gz <<'EOF'
-----BEGIN PUBLIC KEY-----
MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWZrGCUaJJr1H8a36sG4UUoXvlXvZ
wQfk16sxprI2gOJ2vFFggdq3ixF2h4qNBt0kI7ciDhgpwS8t+/960IsIgw==
-----END PUBLIC KEY-----
EOF

    A saída esperada é Verified OK.

  3. Extraia o conteúdo do arquivo em qualquer local no sistema. Por exemplo, para extrair o conteúdo para o diretório de trabalho atual: 
    tar xzf istio-1.5.10-asm.2-linux.tar.gz

    O comando cria um diretório de instalação no seu diretório de trabalho atual, chamado istio-1.5.10-asm.2, que contém o seguinte:

    • aplicativos de amostra em samples;
    • As seguintes ferramentas no diretório bin:
      • istioctl: use istioctl para instalar o Anthos Service Mesh.
      • asmctl: use asmctl para ajudar a validar sua configuração de segurança depois de instalar o Anthos Service Mesh. Atualmente, asmctl não é compatível com clusters do Anthos no VMware.

    4. macOS

  4. Faça o download do arquivo de instalação do Anthos Service Mesh no diretório de trabalho atual: 
    curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.5.10-asm.2-osx.tar.gz
  5. Faça o download do arquivo de assinatura e use openssl para verificar a assinatura: 
    curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.5.10-asm.2-osx.tar.gz.1.sig
openssl dgst -sha256 -verify /dev/stdin -signature istio-1.5.10-asm.2-osx.tar.gz.1.sig istio-1.5.10-asm.2-osx.tar.gz <<'EOF'
-----BEGIN PUBLIC KEY-----
MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWZrGCUaJJr1H8a36sG4UUoXvlXvZ
wQfk16sxprI2gOJ2vFFggdq3ixF2h4qNBt0kI7ciDhgpwS8t+/960IsIgw==
-----END PUBLIC KEY-----
EOF

    A saída esperada é Verified OK.

  6. Extraia o conteúdo do arquivo em qualquer local no sistema. Por exemplo, para extrair o conteúdo para o diretório de trabalho atual: 
    tar xzf istio-1.5.10-asm.2-osx.tar.gz

    O comando cria um diretório de instalação no seu diretório de trabalho atual, chamado istio-1.5.10-asm.2, que contém o seguinte:

    • aplicativos de amostra em samples;
    • As seguintes ferramentas no diretório bin:
      • istioctl: use istioctl para instalar o Anthos Service Mesh.
      • asmctl: use asmctl para ajudar a validar sua configuração de segurança depois de instalar o Anthos Service Mesh. Atualmente, asmctl não é compatível com clusters do Anthos no VMware.

    7. Windows

  7. Faça o download do arquivo de instalação do Anthos Service Mesh no diretório de trabalho atual: 
    curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.5.10-asm.2-win.zip
  8. Faça o download do arquivo de assinatura e use openssl para verificar a assinatura: 
    curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.5.10-asm.2-win.zip.1.sig
openssl dgst -verify - -signature istio-1.5.10-asm.2-win.zip.1.sig istio-1.5.10-asm.2-win.zip <<'EOF'
-----BEGIN PUBLIC KEY-----
MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWZrGCUaJJr1H8a36sG4UUoXvlXvZ
wQfk16sxprI2gOJ2vFFggdq3ixF2h4qNBt0kI7ciDhgpwS8t+/960IsIgw==
-----END PUBLIC KEY-----
EOF

    A saída esperada é Verified OK.

  9. Extraia o conteúdo do arquivo em qualquer local no sistema. Por exemplo, para extrair o conteúdo para o diretório de trabalho atual: 
    tar xzf istio-1.5.10-asm.2-win.zip

    O comando cria um diretório de instalação no seu diretório de trabalho atual, chamado istio-1.5.10-asm.2, que contém o seguinte:

    • aplicativos de amostra em samples;
    • As seguintes ferramentas no diretório bin:
      • istioctl: use istioctl para instalar o Anthos Service Mesh.
      • asmctl: use asmctl para ajudar a validar sua configuração de segurança depois de instalar o Anthos Service Mesh. Atualmente, asmctl não é compatível com clusters do Anthos no VMware.

  10. Verifique se você está no diretório raiz da instalação do Anthos Service Mesh. 
    cd istio-1.5.10-asm.2
  11. Para facilitar, adicione as ferramentas ao diretório /bin/bin do seu PATH. 
    export PATH=$PWD/bin:$PATH

Como preparar arquivos de configuração de recursos

Ao executar istioctl apply command para instalar o Anthos Service Mesh, especifique -f istio-operator.yaml na linha de comando. Este arquivo contém informações sobre seu projeto e cluster que são necessários para ativar os recursos de segurança e telemetria do Mesh. Faça o download do istio-operator.yaml e de outros arquivos de configuração de recursos e defina as informações do cluster e do projeto.

Para preparar os arquivos de configuração de recursos, siga estas etapas:

  1. Instale kpt, caso ainda não tenha feito isso:

    gcloud components install kpt

  2. Opcionalmente, crie um novo diretório para os arquivos de configuração de recursos do pacote do Anthos Service Mesh. Se você planeja configurar mais de um cluster, convém usar o nome do cluster como o nome do diretório.

  3. Altere para o diretório em que você quer fazer o download do pacote do Anthos Service Mesh.

  4. Faça o download do pacote do Anthos Service Mesh no diretório de trabalho atual:

    kpt pkg get \
https://github.com/GoogleCloudPlatform/anthos-service-mesh-packages.git/asm@release-1.5-asm .

  5. Defina o nome do cluster:

      kpt cfg set asm gcloud.container.cluster ${CLUSTER_NAME}

  6. Como opção, personalize os arquivos de configuração do recurso usando os setters kpt. Por padrão, esses setters usam os padrões para gcloud config. Se você definir os padrões gcloud config ou se quiser alterar os valores, execute os seguintes setters:

    • Defina o ID do projeto:

      kpt cfg set asm gcloud.core.project ${PROJECT_ID}

    • Defina a zona ou a região padrão:

      kpt cfg set asm gcloud.compute.location ${CLUSTER_LOCATION}

  7. Se preferir, insira os arquivos de configuração de recursos no seu próprio sistema de controle de origem, como o Cloud Source Repositories, para rastrear as alterações nos arquivos.

Como instalar o Anthos Service Mesh

Instale o Anthos Service Mesh e defina as opções necessárias para integrar o Anthos Service Mesh ao IAP.

PERMISSIVE mTLS

istioctl manifest apply --set profile=asm \
  -f asm/cluster/istio-operator.yaml \
  --set values.gateways.istio-ingressgateway.type=NodePort

STRICT mTLS (em inglês)

istioctl manifest apply --set profile=asm \
  -f asm/cluster/istio-operator.yaml \
  --set values.gateways.istio-ingressgateway.type=NodePort \
  --set values.global.mtls.enabled=true

Especifique NodePort para istio-ingressgateway, que configura {[mesh_name]} para abrir uma porta específica na malha de serviço. Isso permite que você configure um balanceador de carga, que encaminha o tráfego enviado ao seu nome de domínio para essa porta. As outras opções ativam a autoridade de certificação do Anthos Service Mesh (Mesh CA).

Como validar a instalação

Recomendamos que você use a ferramenta de análise asmctl para validar a configuração básica do projeto, do cluster e das cargas de trabalho. Se um teste asmctl falhar, asmctl recomenda soluções, se possível. O comando asmctl validate executa testes básicos que verificam:

  1. que as APIs exigidas pelo Anthos Service Mesh estão ativadas no projeto;
  2. que o Istio-Ingressgateway está configurado corretamente para chamar a CA do Mesh;
  3. a integridade geral do Istiod e do Istio-Ingressgateway.

Se você executar o comando asmctl validate com a sinalização opcional --with-testing-workloads, além dos testes básicos, o asmctl executará testes de segurança que verificam:

  1. se a comunicação TLS mútua (mTLS) está configurada corretamente;
  2. se a CA do Mesh pode emitir certificados.

Para executar os testes de segurança, o asmctl implanta cargas de trabalho no cluster em um namespace de teste, executa os testes de comunicação mTLS, gera os resultados e exclui o namespace de teste.

Para executar asmctl:

  1. Verifique se o Application Default Credentials da gcloud está configurado:

     gcloud auth application-default login

  2. Receba credenciais de autenticação para interagir com o cluster, caso ainda não tenha feito isso:

     gcloud container clusters get-credentials ${CLUSTER_NAME}

  3. Para executar os testes básicos e de segurança, supondo que istio-1.5.10-asm.2/bin esteja no seu PATH:

    asmctl validate --with-testing-workloads

    Se for bem-sucedido, o comando responderá com uma saída semelhante à seguinte:

    [asmctl version 0.3.0]
Using Kubernetes context: example-project_us-central1-example-cluster
To change the context, use the --context flag
Validating enabled APIs
OK
Validating ingressgateway configuration
OK
Validating istio system
OK
Validating sample traffic
Launching example services...
Sent traffic to example service http code: 200
verified mTLS configuration
OK
Validating issued certs
OK

Como implantar um aplicativo de amostra

Antes de ativar o IAP, você precisa de um aplicativo em execução no cluster do GKE para verificar se todas as solicitações têm uma identidade. Neste guia, usamos a amostra do Bookinfo para demonstrar a configuração do balanceador de carga HTTP(S) e a ativação do IAP.

Iniciar os serviços de aplicativo

  1. Altere o diretório para a raiz da instalação do Anthos Service Mesh.

  2. Rotule o namespace default para usar a injeção automática de arquivo secundário:

    kubectl label namespace default istio-injection=enabled

  3. Implante o aplicativo:

    kubectl apply -f samples/bookinfo/platform/kube/bookinfo.yaml

  4. Confirme se todos os serviços do bookinfo estão em execução:

    kubectl get services

    A resposta esperada é semelhante a esta:

    NAME                       CLUSTER-IP   EXTERNAL-IP   PORT(S)              AGE
details                    10.0.0.31            9080/TCP             6m
kubernetes                 10.0.0.1             443/TCP              7d
productpage                10.0.0.120           9080/TCP             6m
ratings                    10.0.0.15            9080/TCP             6m
reviews                    10.0.0.170           9080/TCP             6m

  5. Confirme se todos os pods estão em execução:

    kubectl get pods

    A resposta esperada é semelhante a esta:

    NAME                                        READY     STATUS    RESTARTS   AGE
details-v1-1520924117-48z17                 2/2       Running   0          6m
productpage-v1-560495357-jk1lz              2/2       Running   0          6m
ratings-v1-734492171-rnr5l                  2/2       Running   0          6m
reviews-v1-874083890-f0qf0                  2/2       Running   0          6m
reviews-v2-1343845940-b34q5                 2/2       Running   0          6m
reviews-v3-1813607990-8ch52                 2/2       Running   0          6m

  6. Confirme se o aplicativo Bookinfo está em execução:

    kubectl exec -it $(kubectl get pod -l app=ratings -o jsonpath='{.items[0].metadata.name}') -c ratings -- curl productpage:9080/productpage | grep -o "<title>.*</title>"

    Resposta esperada:

    <title>Simple Bookstore App</title>

  7. Defina o gateway de entrada e o serviço virtual do aplicativo:

    kubectl apply -f samples/bookinfo/networking/bookinfo-gateway.yaml

  8. Confirme se o gateway foi criado:

    kubectl get gateway

    A resposta esperada é semelhante a esta:

    NAME                AGE
bookinfo-gateway    32s

Solicitações externas

O recurso Gateway do Bookinfo, definido em samples/bookinfo/networking/bookinfo-gateway.yaml, usa o istio-ingressgateway pré-configurado. Lembre-se de que, ao implantar o Anthos Service Mesh, você especificou NodePort para istio-ingressgateway, o que abre uma porta específica na malha de serviço. Até que você configure o balanceador de carga, o aplicativo Bookinfo não poderá ser acessado fora do cluster do GKE (por exemplo, a partir de um navegador). Embora os nós do cluster tenham endereços IP externos, as solicitações provenientes de fora do cluster são bloqueadas pelas regras de firewall do Google Cloud. Com o IAP, a maneira correta de expor esse aplicativo à Internet pública é usando um balanceador de carga. Não exponha os endereços de nós usando regras de firewall, que ignoram o IAP.

Para encaminhar solicitações ao Bookinfo, configure um balanceador de carga HTTP(S) no projeto do Cloud. Como o balanceador de carga está no projeto, ele está dentro do firewall e pode acessar os nós do cluster. Depois de configurar o balanceador de carga com o endereço IP estático e o nome de domínio, envie solicitações para o nome de domínio, e o balanceador de carga encaminhará as solicitações para os nós do cluster.

Como implantar o balanceador de carga

É possível usar um recurso da Entrada para criar um balanceador de carga HTTP(S) com certificados SSL configurados automaticamente. Os certificados SSL gerenciados pelo Google são provisionados, renovados e gerenciados para seu domínio.

  1. Crie um recurso ManagedCertificate. Este recurso especifica o domínio do certificado SSL. A lista spec.domains precisa conter apenas um domínio. Domínios com caracteres curinga não são compatíveis.

    cat <<EOF | kubectl apply -f -
apiVersion: networking.gke.io/v1beta1
kind: ManagedCertificate
metadata:
  name: example-certificate
  namespace: istio-system
spec:
  domains:
    - ${DOMAIN_NAME}
EOF

  2. Para criar o balanceador de carga, defina o recurso da Entrada.

    • Defina a anotação networking.gke.io/managed-certificates como o nome do certificado criado na etapa anterior, example-certificate.

    • Defina a anotação kubernetes.io/ingress.global-static-ip-name como o nome do endereço IP estático reservado, example-static-ip.

    • Defina serviceName como istio-ingressgateway, que é usado no recurso Gateway para a amostra Bookinfo.

    cat <<EOF | kubectl create -f -
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: example-ingress
  namespace: istio-system
  annotations:
    kubernetes.io/ingress.global-static-ip-name: example-static-ip
    networking.gke.io/managed-certificates: example-certificate
spec:
  backend:
    serviceName: istio-ingressgateway
    servicePort: 80
EOF

  3. No console do Google Cloud, acesse a página Kubernetes Engine > Serviços e Entrada.

    Acessar a página "Serviços e Entrada"

    Você verá a mensagem "Criando entrada" na coluna Status. Aguarde até que o GKE provisione totalmente a Entrada antes de continuar. Atualize a página periodicamente para ver o status mais atualizado da Entrada. Depois que a Entrada for provisionada, você verá o status "Ok" ou o erro "Todos os serviços de back-end estão no estado NÃO ÍNTEGRO". Um dos recursos provisionados pelo GKE é uma verificação de integridade padrão. Se você vir a mensagem de erro, isso indica que a Entrada foi provisionada e que a verificação de integridade padrão foi executada. Quando aparecer o status "Ok" ou o erro, passe para a próxima seção para configurar as verificações de integridade do balanceador de carga.

Configurar verificações de integridade para o balanceador de carga.

Para configurar as verificações de integridade, você precisa conseguir o ID da verificação de integridade padrão criada pela Entrada e atualizar a verificação de integridade para que use o caminho e a porta de verificação de integridade do istio-ingress.

  1. Consiga novas credenciais de usuário que serão usadas no Application Default Credentials:

      gcloud auth application-default login

  2. Consiga o ID da verificação de integridade padrão criada pela Entrada:

    1. Configure as variáveis de ambiente a seguir:

      • Serviço de back-end: vincula vários grupos de instâncias em um determinado NodePort do serviço. 

        BACKEND_SERVICE=$(gcloud compute url-maps list | grep example-ingress | awk '{print $2}' | cut -d'/' -f 2)

      • Verificação de integridade: essa é a verificação de integridade padrão criada automaticamente quando a Entrada é implantada. 

        HC=$(gcloud compute backend-services describe ${BACKEND_SERVICE} --global | grep healthChecks | cut -d'/' -f 10 | tail -n 1)

      • Porta de entrada da verificação de integridade: é a porta da verificação de integridade do istio-ingress. 

        export HC_INGRESS_PORT=$(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.spec.ports[?(@.name=="status-port")].nodePort}')

      • Caminho de entrada da verificação de integridade: é o caminho de verificação de integridade do istio-ingress. 

        export HC_INGRESS_PATH=$(kubectl -n istio-system get deployments istio-ingressgateway -o jsonpath='{.spec.template.spec.containers[?(@.name=="istio-proxy")].readinessProbe.httpGet.path}')

      • API Health check: é a API que você chama para configurar a verificação de integridade. 
        export HC_API=https://compute.googleapis.com/compute/v1/projects/${PROJECT_ID}/global/healthChecks/${HC}

    2. Para conseguir a verificação de integridade padrão em um arquivo JSON, chame a API healthChecks:

      curl --request GET  --header "Authorization: Bearer $(gcloud auth application-default print-access-token)" ${HC_API} > health_check.json

  3. Atualize a verificação de integridade para usar o caminho e a porta da verificação de integridade do istio-ingress:

    1. Atualize o arquivo health_check.json da seguinte forma:

      • Defina httpHealthCheck.port como o valor de ${HC_INGRESS_PORT}.
      • Defina httpHealthCheck.requestPath como o valor de ${HC_INGRESS_PATH}.
      • Adicione o seguinte atributo e defina-o como uma string vazia: httpHealthCheck.portSpecification=""

      A maneira mais fácil de fazer isso é usando jq, que vem pré-instalado no Cloud Shell:

      jq ".httpHealthCheck.port=${HC_INGRESS_PORT} | .httpHealthCheck.requestPath=\"${HC_INGRESS_PATH}\" | .httpHealthCheck.portSpecification=\"\"" health_check.json > updated_health_check.json

      Se você executar cat no arquivo updated_health_check.json resultante, ele ficará mais ou menos assim:

      {
"id": "5062913090021441698",
"creationTimestamp": "2019-11-12T10:47:41.934-08:00",
"name": "${HC}",
"description": "Default kubernetes L7 Loadbalancing health check.",
"checkIntervalSec": 60,
"timeoutSec": 60,
"unhealthyThreshold": 10,
"healthyThreshold": 1,
"type": "HTTP",
"httpHealthCheck": {
  "port": 32394,
  "requestPath": "/healthz/ready",
  "proxyHeader": "NONE",
  "portSpecification": ""
},
"selfLink": "https://www.googleapis.com/compute/v1/projects/${PROJECT_ID}/global/healthChecks/${HC}",
"kind": "compute#healthCheck"
}

      Se você tiver editado o arquivo JSON manualmente, e não usando o comando jq, salve o arquivo como updated_health_check.json para que corresponda ao nome de arquivo no próximo comando.

    2. Atualize a verificação de integridade:

      curl --request PATCH --header "Authorization: Bearer $(gcloud auth application-default print-access-token)" --header "Content-Type: application/json" --data @updated_health_check.json ${HC_API}

    O GKE leva vários minutos para atualizar a verificação de integridade. No Console do Google Cloud, atualize a página Kubernetes Engine > Serviços e entrada a cada minuto até que o status da Entrada mude para "Ok.".

  4. Teste o balanceador de carga. Aponte seu navegador para:

    http://YOUR_DOMAIN_NAME/productpage

    em que YOUR_DOMAIN_NAME é o nome de domínio que você configurou com o endereço IP estático externo.

    Você verá a productpage do aplicativo Bookinfo. Se você atualizar a página várias vezes, verá diferentes versões das avaliações, apresentadas em estilo round-robin: estrelas vermelhas, estrelas pretas, sem estrelas.

    Teste também o acesso https ao Bookinfo.

Como ativar o IAP

Veja nas etapas a seguir como ativar o IAP.

  1. Verifique se você já tem uma marca usando o comando list. É possível ter apenas uma marca por projeto.

    gcloud iap oauth-brands list

    Veja um exemplo de resposta do gcloud, se a marca existir:

    name: projects/[PROJECT_NUMBER]/brands/[BRAND_ID]
applicationTitle: [APPLICATION_TITLE]
supportEmail: [SUPPORT_EMAIL]
orgInternalOnly: true

  2. Se não houver marca, use o comando create:

    gcloud iap oauth-brands create --application_title=APPLICATION_TITLE --support_email=SUPPORT_EMAIL

    Os campos acima são obrigatórios ao chamar esta API:

    • supportEmail: o e-mail de suporte exibido na tela de consentimento do OAuth. Esse endereço de e-mail pode ser um endereço de usuário ou um alias dos Grupos do Google. Embora as contas de serviço também tenham um endereço de e-mail, elas não são endereços de e-mail válidos e não podem ser usadas ao criar uma marca. No entanto, uma conta de serviço pode ser a proprietária de um Grupo do Google. Crie um novo Grupo do Google ou configure um grupo existente e defina a conta de serviço desejada como proprietário do grupo.

    • applicationTitle: o nome do aplicativo exibido na tela de consentimento do OAuth.

    A resposta contém os seguintes campos:

    name: projects/[PROJECT_NUMBER]/brands/[BRAND_ID]
applicationTitle: [APPLICATION_TITLE]
supportEmail: [SUPPORT_EMAIL]
orgInternalOnly: true

Como criar um cliente OAuth do IAP

  1. Use o comando create para criar um cliente. Use a marca name da etapa anterior.

    gcloud iap oauth-clients create projects/PROJECT_NUMBER/brands/BRAND-ID --display_name=NAME

    A resposta contém os seguintes campos:

    name: projects/[PROJECT_NUMBER]/brands/[BRAND_NAME]/identityAwareProxyClients/[CLIENT_ID]
secret: [CLIENT_SECRET]
displayName: [NAME]

Como ativar o IAP para o serviço

Use o comando a seguir para ativar o IAP para seu serviço. Substitua CLIENT_ID e CLIENT_SECRET pelo ID do cliente OAuth e pela chave secreta do cliente criados anteriormente.

gcloud beta iap web enable \
    --oauth2-client-id=CLIENT_ID \
    --oauth2-client-secret=CLIENT_SECRET \
    --resource-type=backend-services \
    --service=${BACKEND_SERVICE}

Configurar a lista de acesso do IAP

Adicione um usuário à política de acesso do IAP:

gcloud beta iap web add-iam-policy-binding \
    --member=user:EMAIL_ADDRESS \
    --role=roles/iap.httpsResourceAccessor \
    --resource-type=backend-services \
    --service=$BACKEND_SERVICE

em que EMAIL_ADDRESS é o endereço de e-mail completo do usuário, como alice@example.com.

Ativar o suporte ao RCToken na malha de serviço

Por padrão, o IAP gera um JSON Web Token (JWT) com escopo para o cliente OAuth. No Anthos Service Mesh, é possível configurar o IAP para gerar um RequestContextToken (RCToken), que é um JWT, mas com um público configurável. O RCToken permite configurar o público do JWT para uma string arbitrária, que pode ser usada nas políticas do Anthos Service Mesh para autorização refinada.

Para configurar o RCToken:

  1. Crie uma variável de ambiente para o número do projeto. Esse é o número que foi gerado e atribuído automaticamente ao projeto quando você o criou. Ele não é o mesmo que o ID do projeto.

    export PROJECT_NUMBER=YOUR_PROJECT_NUMBER

  2. Crie uma variável de ambiente para o público do RCToken. Pode ser qualquer string que você quiser.

    export RCTOKEN_AUD="your-rctoken-aud"

  3. Busque as configurações existentes do IAP

    gcloud beta iap settings get --format json \
--project=${PROJECT_NUMBER} --resource-type=compute \
--service=${BACKEND_SERVICE} > iapSettings.json

  4. Atualize IapSettings com o público do RCToken.

    cat iapSettings.json | jq --arg RCTOKEN_AUD_STR $RCTOKEN_AUD \
'. + {applicationSettings: {csmSettings: {rctokenAud: $RCTOKEN_AUD_STR}}}' \
> updatedIapSettings.json

    gcloud beta iap settings set updatedIapSettings.json --format json \
--project=${PROJECT_NUMBER} --resource-type=compute --service=${BACKEND_SERVICE}

  5. Ative a autenticação RCToken no gateway de entrada do Istio.

    cat <<EOF | kubectl apply -f -
apiVersion: "authentication.istio.io/v1alpha1"
kind: "Policy"
metadata:
  name: "ingressgateway"
  namespace: istio-system
spec:
  targets:
  - name: "istio-ingressgateway"
  origins:
  - jwt:
      issuer: "https://cloud.google.com/iap"
      jwksUri: "https://www.gstatic.com/iap/verify/public_key-jwk"
      audiences:
      - "$RCTOKEN_AUD"
      jwt_headers:
      - "ingress-authorization"
      trigger_rules:
      - excluded_paths:
        - exact: /healthz/ready
  principalBinding: USE_ORIGIN
EOF

  6. Verifique se as solicitações para a productpage do Bookinfo ainda estão bem-sucedidas:

    http://DOMAIN_NAME/productpage

Para testar a política:

  1. Crie um objeto de solicitação IapSettings, mas defina rctokenAud como uma string diferente:

    echo $(cat <<EOF
{
   "name": "projects/${PROJECT_NUMBER}/iap_web/compute/services/${BACKEND_SERVICE}",
   "applicationSettings": {
     "csmSettings": {
       "rctokenAud": "some-other-arbitrary-string"
     }
   }
 }
EOF
) > request.txt

  2. Chame a API IapSettings para definir o público do RCtoken.

    curl --request PATCH --header "Authorization: Bearer $(gcloud beta auth application-default print-access-token)" ${IAP_SETTINGS_API}

  3. Faça uma solicitação para o Bookinfo productpage e ela falhará:

    http://DOMAIN_NAME/productpage

Como fazer a limpeza

Depois de concluir este tutorial, remova os seguintes recursos para evitar cobranças indesejadas na sua conta:

  1. Exclua o certificado gerenciado:

    kubectl delete managedcertificates example-certificate

  2. Exclua a Entrada, que desaloca os recursos de balanceamento de carga: 

    kubectl -n istio-system delete ingress example-ingress

  3. Exclua o endereço IP estático:

    gcloud compute addresses delete example-static-ip --global

    Se fizer isso, exclua o endereço IP do registrador de domínio.

  4. Exclua o cluster, o que exclui os recursos que compõem o cluster, como instâncias de computação, discos e recursos de rede: 

    gcloud container clusters delete ${CLUSTER_NAME}