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:
- Configure seu projeto do Google Cloud para conceder as permissões e ativar as APIs do Google exigidas pelo IAP.
- 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.
- Configure um novo cluster do Google Kubernetes Engine (GKE) com as opções necessárias para integrar o IAP ao Anthos Service Mesh.
- Instale o Anthos Service Mesh com as opções necessárias para a integração.
- Implante um aplicativo de amostra.
- 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.
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:
- No mínimo, quatro nós.
- O tipo de máquina mínimo
é
e2-standard-4
, que tem quatro vCPUs. - Use um canal de lançamento em vez de uma versão estática do GKE
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
ehelm
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:
- Acesse o Console do Google Cloud.
- Selecione seu projeto do Google Cloud.
Clique no botão Ativar Cloud Shell na parte superior da janela do console do Google Cloud.
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.
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 ...
Copie o comando longo e cole-o para atualizar os componentes.
Instale
kubectl
:sudo apt-get install kubectl
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:
Faça a autenticação com a gcloud CLI:
gcloud auth login
Atualize os componentes:
gcloud components update
Instale
kubectl
:gcloud components install kubectl
Instale
kpt
:gcloud components install kpt
Configurar o projeto
-
Encontre o ID do projeto em que o cluster será criado:
gcloud
gcloud projects list
Console
- No console do Google Cloud, abra a página Painel.
-
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.
- Crie uma variável de ambiente para o ID do projeto:
export PROJECT_ID=YOUR_PROJECT_ID
-
Defina o ID do projeto padrão para a ferramenta de linha de comando
gcloud
:gcloud config set project ${PROJECT_ID}
- Crie uma variável de ambiente para o número do projeto:
export PROJECT_NUMBER=$(gcloud projects describe ${PROJECT_ID} --format="value(projectNumber)")
-
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
- 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.
Reserve um endereço IP externo estático.
gcloud compute addresses create example-static-ip --global
Consiga o endereço IP estático:
gcloud compute addresses describe example-static-ip --global
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 registroA
para um FQDN variam de acordo com o registrador de domínios.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:
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
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
ourapid
.export CHANNEL=YOUR_CHANNEL
Veja uma descrição de cada canal em Quais canais estão disponíveis.
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 comandosgcloud
que definem valores padrão ao script. Outra opção é usargcloud init
para criar e ativar uma configuraçãogcloud
nomeada.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ótulomesh_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
.
-
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
-
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
. -
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
-
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
. -
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
-
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
. -
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
: useistioctl
para instalar o Anthos Service Mesh.asmctl
: useasmctl
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.
- aplicativos de amostra em
-
Verifique se você está no diretório raiz da instalação do Anthos Service Mesh.
cd istio-1.4.10-asm.18
-
Para facilitar, adicione as ferramentas ao diretório
/bin
do seu caminho:export PATH=$PWD/bin:$PATH
Linux
macOS
Windows
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
Altere o diretório para a raiz da instalação do Anthos Service Mesh.
Rotule o namespace
default
para usar a injeção automática de arquivo secundário:kubectl label namespace default istio-injection=enabled
Implante o aplicativo:
kubectl apply -f samples/bookinfo/platform/kube/bookinfo.yaml
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 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
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>
Defina o gateway de entrada e o serviço virtual do aplicativo:
kubectl apply -f samples/bookinfo/networking/bookinfo-gateway.yaml
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.
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
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
comoistio-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
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.
Consiga novas credenciais de usuário que serão usadas no Application Default Credentials:
gcloud auth application-default login
Consiga o ID da verificação de integridade padrão criada pela Entrada:
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}
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
Atualize a verificação de integridade para usar o caminho e a porta da verificação de integridade do istio-ingress:
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 arquivoupdated_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 comoupdated_health_check.json
para que corresponda ao nome de arquivo no próximo comando.- Defina
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.".
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.
Como configurar a tela de consentimento
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
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
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:
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
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"
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
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}
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
Verifique se as solicitações para a
productpage
do Bookinfo ainda estão bem-sucedidas:http://DOMAIN_NAME/productpage
Para testar a política:
Crie um objeto de solicitação
IapSettings
, mas definarctokenAud
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
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}
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.
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"
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.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:
Exclua o certificado gerenciado:
kubectl delete managedcertificates example-certificate
Exclua a Entrada, que desaloca os recursos de balanceamento de carga:
kubectl -n istio-system delete ingress example-ingress
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.
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}