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 estiver instalando o Anthos Service Mesh em um cluster privado, será necessário adicionar uma regra de firewall para abrir a porta 9443 se quiser 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.

Se a gcloud CLI já estiver instalada:

  1. Faça a autenticação com a gcloud 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

Nesta seção, explicaremos os conceitos básicos da criação de um cluster do GKE com as opções necessárias para o Anthos Service Mesh. Saiba mais em Como criar um cluster.

Para configurar um novo cluster, siga estas etapas:

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

    • Se você criar um cluster de zona única, execute o seguinte comando para ver uma lista das zonas do GCP disponíveis:

      gcloud compute zones list
      
    • Se você estiver criando um cluster regional, execute o seguinte comando para ver uma lista das regiões disponíveis:

      gcloud compute regions 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 a CLUSTER_LOCATION como a zona ou a região do cluster:

      export CLUSTER_LOCATION=YOUR_ZONE_OR_REGION
    • 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}"
    • Defina o canal de lançamento. Substitua YOUR_CHANNEL por um dos seguintes: regular, stable ou rapid.

      export CHANNEL=YOUR_CHANNEL

      Veja uma descrição de cada canal em Quais canais estão disponíveis.

  3. Defina a zona ou a região padrão da Google Cloud CLI.

    • Para um cluster de zona única, defina a zona padrão:

      gcloud config set compute/zone ${CLUSTER_LOCATION}
    • Para um cluster regional, defina a região padrão:

      gcloud config set compute/region ${CLUSTER_LOCATION}

    Dica: para facilitar a configuração do ambiente shell no futuro, copie e cole as instruções export de cada variável de ambiente em um script de shell simples que você source ao iniciar um novo shell. Também é possível adicionar os comandos gcloud que definem valores padrão ao script. Outra opção é usar gcloud init para criar e ativar uma configuração gcloud nomeada.

  4. 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 e2-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} \
        --machine-type=e2-standard-4 \
        --num-nodes=4 \
        --workload-pool=${WORKLOAD_POOL} \
        --enable-stackdriver-kubernetes \
        --subnetwork=default \
        --labels=mesh_id=${MESH_ID} \
        --release-channel=${CHANNEL}

    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, que é necessário para que as métricas sejam exibidas nas páginas do Anthos Service Mesh no Console do Google Cloud.

    • release-channel ${CHANNEL}: registra o cluster no canal de lançamento especificado.

Como preparar a instalação do Anthos Service Mesh

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.4.10-asm.18-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.4.10-asm.18-linux.tar.gz.1.sig
    openssl dgst -verify - -signature istio-1.4.10-asm.18-linux.tar.gz.1.sig istio-1.4.10-asm.18-linux.tar.gz <<'EOF'
    -----BEGIN PUBLIC KEY-----
    MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWZrGCUaJJr1H8a36sG4UUoXvlXvZ
    wQfk16sxprI2gOJ2vFFggdq3ixF2h4qNBt0kI7ciDhgpwS8t+/960IsIgw==
    -----END PUBLIC KEY-----
    EOF

    A saída esperada é Verified OK.

  3. 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.4.10-asm.18-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.4.10-asm.18-osx.tar.gz.1.sig
    openssl dgst -sha256 -verify /dev/stdin -signature istio-1.4.10-asm.18-osx.tar.gz.1.sig istio-1.4.10-asm.18-osx.tar.gz <<'EOF'
    -----BEGIN PUBLIC KEY-----
    MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWZrGCUaJJr1H8a36sG4UUoXvlXvZ
    wQfk16sxprI2gOJ2vFFggdq3ixF2h4qNBt0kI7ciDhgpwS8t+/960IsIgw==
    -----END PUBLIC KEY-----
    EOF

    A saída esperada é Verified OK.

  6. 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.4.10-asm.18-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.4.10-asm.18-win.zip.1.sig
    openssl dgst -verify - -signature istio-1.4.10-asm.18-win.zip.1.sig istio-1.4.10-asm.18-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.4.10-asm.18-linux.tar.gz

    O comando cria um diretório de instalação no seu diretório de trabalho atual, chamado istio-1.4.10-asm.18, 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.4.10-asm.18
  11. Para facilitar, adicione as ferramentas ao diretório /bin do seu caminho:
    export PATH=$PWD/bin:$PATH

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 \
  --set values.gateways.istio-ingressgateway.type=NodePort \
  --set values.global.trustDomain=${WORKLOAD_POOL} \
  --set values.global.sds.token.aud=${WORKLOAD_POOL} \
  --set values.nodeagent.env.GKE_CLUSTER_URL=https://container.googleapis.com/v1/projects/${PROJECT_ID}/locations/${CLUSTER_LOCATION}/clusters/${CLUSTER_NAME} \
  --set values.global.meshID=${MESH_ID} \
  --set values.global.proxy.env.GCP_METADATA="${PROJECT_ID}|${PROJECT_NUMBER}|${CLUSTER_NAME}|${CLUSTER_LOCATION}"

STRICT mTLS (em inglês)

istioctl manifest apply --set profile=asm \
  --set values.gateways.istio-ingressgateway.type=NodePort \
  --set values.global.trustDomain=${WORKLOAD_POOL} \
  --set values.global.sds.token.aud=${WORKLOAD_POOL} \
  --set values.nodeagent.env.GKE_CLUSTER_URL=https://container.googleapis.com/v1/projects/${PROJECT_ID}/locations/${CLUSTER_LOCATION}/clusters/${CLUSTER_NAME} \
  --set values.global.meshID=${MESH_ID} \
  --set values.global.proxy.env.GCP_METADATA="${PROJECT_ID}|${PROJECT_NUMBER}|${CLUSTER_NAME}|${CLUSTER_LOCATION}" \
  --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).

Verificar os componentes do plano de controle

Verifique se os pods do plano de controle em istio-system estão ativos:

kubectl get pod -n istio-system

Espere para ver uma saída semelhante a esta:

NAME                                      READY   STATUS      RESTARTS   AGE
istio-galley-5c65896ff7-m2pls             2/2     Running     0          18m
istio-ingressgateway-587cd459f-q6hqt      2/2     Running     0          18m
istio-nodeagent-74w69                     1/1     Running     0          18m
istio-nodeagent-7524w                     1/1     Running     0          18m
istio-nodeagent-7652w                     1/1     Running     0          18m
istio-nodeagent-7948w                     1/1     Running     0          18m
istio-pilot-9db77b99f-7wfb6               2/2     Running     0          18m
istio-sidecar-injector-69c4d9f875-dt8rn   1/1     Running     0          18m
promsd-55f464d964-lqs7w                   2/2     Running     0          18m

Você verá uma instância de istio-nodeagent para cada nó no seu cluster. O Mesh CA, que substitui o componente Citadel OSS Istio, cria os agentes de nó para emitir certificados mTLS para as cargas de trabalho em execução na malha de serviço.

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 Google 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
    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 ativar as políticas de segurança de pods

Ao ativar as políticas de segurança do pod, você garante que os namespaces comprometidos (exceto istio-system) não afetem a segurança de outros namespaces que compartilham os mesmos nós. Os arquivos de recursos PodSecurityPolicy de amostra que funcionam com o Mesh CA são fornecidos com o Anthos Service Mesh. É possível modificar esses arquivos conforme necessário. A seguir, primeiro aplique as políticas de segurança do pod e, em seguida, ative a política de segurança do pod para o cluster do GKE.

  1. Aplique a política de segurança padrão do pod a todas as contas de serviço no cluster:

    kubectl apply -f "samples/security/psp/all-pods-psp.yaml"
    
  2. Aplique a política de segurança do pod para proteger o serviço de descoberta secreta (SDS, na sigla em inglês):

    kubectl apply -f "samples/security/psp/citadel-agent-psp.yaml"
    

    Isso dá ao agente do Citadel (também conhecido como o agente de nó) o privilégio para criar o caminho UDS /var/run/sds na VM do host.

  3. Execute o seguinte comando para ativar a política de segurança do pod:

    gcloud beta container clusters update ${CLUSTER_NAME} \
        --enable-pod-security-policy
    

    A ativação das políticas de segurança do pod pode levar vários minutos. Durante esse processo, as cargas de trabalho atuais não poderão se conectar ao mestre do Kubernetes. Aguarde o mestre do Kubernetes ficar ativo. Verifique o status do cluster no Console do Google Cloud na página de clusters do Kubernetes.

    Para mais informações, consulte Como usar políticas de segurança de pods.

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}