Você está vendo a documentação legada da Service Mesh v1.20.

Versões disponíveis

Cloud Service Mesh
Arquivo 1.22
Arquivo 1.21
Arquivo 1.20
Arquivo 1.19
Arquivo 1.18

Esta página foi traduzida pela API Cloud Translation.

Como integrar o IAP ao Cloud Service Mesh

Neste guia, descrevemos como integrar o Identity-Aware Proxy (IAP) ao Cloud Service Mesh. O Integração do IAP com o Cloud Service Mesh permite que você acesse serviços de forma segura com base na Princípios do BeyondCorp. 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 Cloud Service Mesh oferece os seguintes benefícios:

Controle total de acesso baseado no contexto das cargas de trabalho em execução no Cloud 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.
Ative o suporte para declarações baseadas no contexto na autorização do Cloud 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.

Pré-requisitos

Siga as etapas em Instalar ferramentas dependentes e validar o cluster para realizar as seguintes ações:

Além disso, este guia pressupõe que você tenha:

Como configurar um cluster com o Anthos Service Mesh

Nesta seção, explicamos como configurar a integração do IAP. para novas instalações do Cloud Service Mesh e upgrades.

Novas instalações

Ative iap.googleapis.com. No comando a seguir, substitua PROJECT_ID pelo projeto em que você vai instalar o Cloud Service Mesh:
```
gcloud services enable \
  --project=PROJECT_ID \
  iap.googleapis.com
```
O cluster que você está atualizando precisa ter a opção --addons=HttpLoadBalancing definida. O complemento HttpLoadBalancing ativa um controlador de balanceamento de carga HTTP (L7) no cluster. Execute o comando a seguir para atualizar o cluster com as opções exigidas pelo Cloud Service Mesh. A menos que você tenha definido uma zona ou região padrão, é necessário fornecer a região (--region=REGION) ou a zona (--zone=ZONE) no comando.
```
gcloud container clusters update CLUSTER_NAME \
  --project=PROJECT_ID \
  --update-addons=HttpLoadBalancing=ENABLED
```
Por padrão, o arquivo iap-operator.yaml tem a porta 31223 definida como a porta de status e a porta 31224 definida como a porta HTTP. Se a porta 31223 já estiver em uso no cluster, execute o comando a seguir para definir outra porta de status:

Importante: use uma versão do kpt anterior à v1.0.
```
kpt cfg set asm gcloud.container.cluster.ingress.statusPort STATUS_PORT
```
Se a porta 31224 já estiver em uso no cluster, execute o comando a seguir para definir outra porta HTTP:
```
kpt cfg set asm gcloud.container.cluster.ingress.httpPort HTTP_PORT
```
Siga as etapas em Instalar recursos padrão e CA da malha usar um script fornecido pelo Google para instalar o Cloud Service Mesh. Ao executar o script, inclua a seguinte opção:
```
--option iap-operator
```
Exemplo:
```
./asmcli install \
  --project_id "PROJECT_ID" \
  --cluster_name "CLUSTER_NAME" \
  --cluster_location "CLUSTER_LOCATION" \
  --fleet_id FLEET_PROJECT_ID \
  --output_dir DIR_PATH \
  --enable_all \
  --option iap-operator
```
Quando você instala o Cloud Service Mesh, iap-operator.yaml define o campo type no serviço istio-ingressgateway como NodePort, que configura o gateway para abrir uma porta específica na e da 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.
Se você estiver instalando o Cloud Service Mesh gerenciado, conclua também seguintes etapas:
1. Aplique o rótulo de revisão ao namespace istio-system.
2. Faça o download da especificação do serviço de gateway de entrada do Istio para o IAP e o nomeie como iap_operator.yaml.
3. Instale a entrada como um serviço NodePort. Para mais informações, consulte Migrar do IstioOperator.
```
asmcli experimental mcp-migrate-check -f iap_operator.yaml

istioctl install -f /asm-generated-configs/gateways-istiooperator/"GATEWAY_NAME".yaml
```

Depois de instalar o Cloud Service Mesh, retorne a este guia e continue com a próxima seção para configurar a integração com o IAP.

Upgrades

Nesta seção, abordamos os seguintes casos de uso de upgrade:

Você já configurou a integração do IAP e está fazendo upgrade do Cloud Service Mesh. Nesse caso, você já ativou iap.googleapis.com no projeto e o complemento HttpLoadBalancing no cluster. Pule para a etapa 3 para fazer o download do pacote asm e e fazer upgrade do Cloud Service Mesh.
Você está fazendo upgrade do Cloud Service Mesh e quer configurar a integração com o o IAP pela primeira vez. Nesse caso, será necessário concluir todas as etapas a seguir, fazer upgrade do Cloud Service Mesh e retornar a este guia após o upgrade para concluir a integração.

Ative iap.googleapis.com. No comando a seguir, substitua PROJECT_IDpelo projeto que você instalará Entrada no Cloud Service Mesh.
```
gcloud services enable \
  --project=PROJECT_ID \
  iap.googleapis.com
```
O cluster que você está atualizando precisa ter a opção --addons=HttpLoadBalancing definida. O complemento HttpLoadBalancing ativa um controlador de balanceamento de carga HTTP (L7) no cluster. Execute o comando a seguir para atualizar o cluster com as opções exigidas pelo Cloud Service Mesh; A menos que você tenha definido uma zona ou região padrão, é necessário fornecer a região (--region=REGION) ou a zona (--zone=ZONE) no comando.
```
gcloud container clusters update CLUSTER_NAME \
  --project=PROJECT_ID
  --update-addons=HttpLoadBalancing=ENABLED
```

Se você estiver atualizando um balanceador de carga HTTP do Cloud funcional, execute o comando a seguir para preservar as portas HTTP e de status existentes:

kpt cfg set asm gcloud.container.cluster.ingress.httpPort $(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.spec.ports[?(@.name=="http2")].nodePort}')

kpt cfg set asm gcloud.container.cluster.ingress.statusPort $(kubectl -n istio-system get service istio-ingressgateway -o jsonpath='{.spec.ports[?(@.name=="status-port")].nodePort}')

Siga as etapas em Como fazer upgrade do Cloud Service Mesh a usar um script fornecido pelo Google para fazer upgrade do Cloud Service Mesh.

Quando você faz upgrade do Cloud Service Mesh, o arquivo iap-operator.yaml define o campo type no serviço istio-ingressgateway como NodePort, que configura o gateway 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.

Por padrão, o arquivo iap-operator.yaml tem a porta 31223 definida como a porta de status e a porta 31224 definida como a porta HTTP.

Ao executar o script, inclua a seguinte opção:
```
--option iap-operator
```
Exemplo:
```
./asmcli install \
  --project_id "PROJECT_ID" \
  --cluster_name "CLUSTER_NAME" \
  --cluster_location "CLUSTER_LOCATION" \
  --fleet_id FLEET_PROJECT_ID \
  --output_dir DIR_PATH \
  --enable_all \
  --option iap-operator
```
Conclua o upgrade acionando a injeção automática de proxy sidecar nas cargas de trabalho. Para mais detalhes, consulte Como implantar e reimplantar cargas de trabalho.

Após concluir o upgrade, retorne a este guia e continue para a próxima seção para configurar a integração com o IAP.

Como reservar um endereço IP estático e configurar o DNS

Para integrar o Identity-Aware Proxy ao Cloud Service Mesh, você precisa configurar uma Balanceador de carga HTTP(S) do Google Cloud, que exige 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 registro A para um FQDN variam de acordo com o registrador de domínios.

Pode levar de 24 a 48 horas para que a configuração de DNS seja propagada. Você pode continuar configurando tudo neste guia, mas não será possível testar a configuração até que as configurações de DNS sejam propagadas.

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.

Siga as etapas para implantar o Bookinfo. Até que você implante o balanceador de carga, o aplicativo Bookinfo não poderá ser acessado fora do cluster do GKE (como em um navegador).

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 Cloud Service Mesh, você especificou NodePort para a istio-ingressgateway, que abre uma porta específica na malha de serviço. 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 aplicativos na 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 ativar o IAP

Veja nas etapas a seguir como ativar o IAP.

Use o ID do cliente (CLIENT_ID na etapa acima) e CLIENT_SECRET para ativar o Cloud Service Mesh. Crie um secret do Kubernetes com os materiais de seu cliente OAuth:
```
kubectl create secret generic -n istio-system my-secret --from-literal=client_id=CLIENT_ID \
--from-literal=client_secret=CLIENT_SECRET
```

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 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. No YAML a seguir, substitua DOMAIN_NAME pelo nome de domínio que você configurou para o endereço IP estático externo.
```
cat <<EOF | kubectl apply -f -
apiVersion: networking.gke.io/v1
kind: ManagedCertificate
metadata:
  name: example-certificate
  namespace: istio-system
spec:
  domains:
    - DOMAIN_NAME
EOF
```

Crie um recurso BackendConfig. Esse recurso instrui o GCLB a realizar verificações de integridade no gateway de entrada, além de configurar o Identity-Aware Proxy. Primeiro, colete alguns valores do gateway de entrada sobre verificações de integridade:

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 get pods -n istio-system -l app=istio-ingressgateway -o jsonpath='{.items[0].spec.containers[?(@.name=="istio-proxy")].readinessProbe.httpGet.path}')

cat <<EOF | kubectl apply -n istio-system -f -
apiVersion: cloud.google.com/v1
kind: BackendConfig
metadata:
  name: http-hc-config
spec:
  healthCheck:
    checkIntervalSec: 2
    timeoutSec: 1
    healthyThreshold: 1
    unhealthyThreshold: 10
    port: ${HC_INGRESS_PORT}
    type: HTTP
    requestPath: ${HC_INGRESS_PATH}
  iap:
    enabled: true
    oauthclientCredentials:
      secretName: my-secret
EOF

Anote o serviço de entrada com o BackendConfig.

    kubectl annotate -n istio-system service/istio-ingressgateway --overwrite \
      cloud.google.com/backend-config='{"default": "http-hc-config"}' \
      cloud.google.com/neg='{"ingress":false}'

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 apply -f -
apiVersion: networking.k8s.io/v1
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:
  defaultBackend:
    service:
      name: istio-ingressgateway
      port:
        number: 80
EOF
```
Observação: pode levar de 10 a 20 minutos para o balanceador de carga ser funcional.
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 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

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

Teste o balanceador de carga. Aponte seu navegador para:
```
http://DOMAIN_NAME/productpage
```
em que 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.

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 Cloud 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 usado nas políticas do Cloud Service Mesh para autorização granular.

Para configurar o RCToken:

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"
```
Opcional: a etapa a seguir exige o BACKEND_SERVICE_ID. Se você precisar descobrir o BACKEND_SERVICE_ID, execute o seguinte comando:
```
kubectl -n istio-system get Ingress example-ingress -o json | jq \
 '.metadata.annotations."ingress.kubernetes.io/backends"'
```
A resposta esperada é semelhante a "{\"BACKEND_SERVICE_ID\":\"HEALTHY\"}". Por exemplo, "ingress.kubernetes.io/backends": "{\"k8s-be-31224--51f3b55cd1457fb6\":\"HEALTHY\"}". Neste exemplo, a BACKEND_SERVICE_ID é k8s-be-31224--51f3b55cd1457fb6.

Busque as configurações atuais do IAP.

gcloud iap settings get --format json \
--project=${PROJECT_ID} --resource-type=compute --service=BACKEND_SERVICE_ID > 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 iap settings set updatedIapSettings.json --format json \
--project=${PROJECT_ID} --resource-type=compute --service=BACKEND_SERVICE_ID

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

cat <<EOF | kubectl apply -f -
apiVersion: "security.istio.io/v1beta1"
kind: "RequestAuthentication"
metadata:
  name: "ingressgateway-jwt-policy"
  namespace: "istio-system"
spec:
  selector:
    matchLabels:
      app: istio-ingressgateway
  jwtRules:
  - issuer: "https://cloud.google.com/iap"
    jwksUri: "https://www.gstatic.com/iap/verify/public_key-jwk"
    audiences:
    - $RCTOKEN_AUD
    fromHeaders:
    - name: ingress-authorization
      prefix: "Istio "
    outputPayloadToHeader: "verified-jwt"
    forwardOriginalToken: true
EOF

Opcional: garanta que as solicitações que não tenham JWTs válidos sejam rejeitadas:

  cat <<EOF | kubectl apply -f -
  apiVersion: security.istio.io/v1beta1
  kind: AuthorizationPolicy
  metadata:
    name: iap-gateway-require-jwt
    namespace: istio-system
  spec:
    selector:
      matchLabels:
        app: istio-iap-ingressgateway
    action: DENY
    rules:
      - from:
          - source:
              notRequestPrincipals: ["*"]
  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 defina rctokenAud como uma string diferente:

cat iapSettings.json | jq --arg RCTOKEN_AUD_STR wrong-rctoken-aud \
'. + {applicationSettings: {csmSettings: {rctokenAud: $RCTOKEN_AUD_STR}}}' \
> wrongIapSettings.json

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

gcloud beta iap settings set wrongIapSettings.json --project=PROJECT_ID --resource-type=compute --service=BACKEND_SERVICE

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:

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
```