Como configurar o Cloud Run para Anthos no Google Cloud

Neste guia, mostramos como configurar um novo cluster do Google Kubernetes Engine com o Cloud Run para Anthos no Google Cloud ativado. Como é possível usar o Console do Cloud ou a linha de comando gcloud, as instruções abrangem ambos. Se você estiver ativando o Cloud Run em um cluster já existente, consulte Como ativar o Cloud Run para Anthos no Google Cloud em clusters atuais.

A ativação do Cloud Run para Anthos no Google Cloud instala o Istio e o Knative Serving no cluster para conectar e gerenciar suas cargas de trabalho sem estado. Para mais informações, consulte Visão geral da arquitetura do Cloud Run para Anthos no Google Cloud.

Pré-requisitos

Você precisa ter uma assinatura do Anthos. Uma avaliação gratuita está disponível até 31 de março de 2021. Saiba mais sobre preços.

Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

No Console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

Acessar o seletor de projetos

Verifique se o faturamento está ativado para seu projeto na nuvem. Saiba como confirmar se o faturamento está ativado para o projeto.

Como configurar o gcloud

É possível usar o Console do Cloud ou a linha de comando gcloud para usar o Cloud Run para Anthos no Google Cloud, mas talvez seja necessário usar a linha de comando gcloud para algumas tarefas.

Para configurar a linha de comando gcloud do Cloud Run para Anthos no Google Cloud:

Instale e inicie o SDK do Cloud.
Defina a configuração padrão do projeto para gcloud como a que você acabou de criar:
```
gcloud config set project PROJECT-ID
```
Substitua PROJECT-ID pelo ID do projeto que você criou.
Defina zone como a zona de sua escolha para o novo cluster. É possível usar qualquer zona compatível com o GKE, por exemplo:
```
gcloud config set compute/zone ZONE
```
Substitua ZONE pela sua zona.
Ative as APIs do projeto a seguir, necessárias para criar um cluster, compilar e publicar um contêiner no Google Container Registry:
```
gcloud services enable container.googleapis.com containerregistry.googleapis.com cloudbuild.googleapis.com
```
Atualize os componentes da gcloud instalados:
```
gcloud components update
```
Instale a ferramenta de linha de comando kubectl:
```
gcloud components install kubectl
```

Como criar um cluster com o Cloud Run ativado

Nestas instruções, criaremos um cluster com esta configuração:

Cloud Run para Anthos no ativado Google Cloud
Versão do Kubernetes: consulte Versões do GKE disponíveis
Nós com duas vCPUs

Estas são as configurações recomendadas para um novo cluster.

É possível usar a linha de comando gcloud ou o Console para criar um cluster. Clique na guia apropriada para ver instruções.

Console

Para criar um cluster e ativá-lo no Cloud Run para Anthos no Google Cloud:

Acesse a página do Google Kubernetes Engine no Console do Cloud:

Acessar o Google Kubernetes Engine
Clique em Criar cluster para abrir a página Criar um cluster do Kubernetes.
Na seção Princípios básicos do cluster, conclua o seguinte:
- Insira o Nome do cluster.
- Escolha Zonal ou regional para o tipo de local: ambos funcionarão com o Cloud Run para Anthos no Google Cloud. Os clusters zonais são mais baratos, mas geram inatividade durante os upgrades do plano de controle (mestre).
- Selecione uma zona ou região para o cluster dependendo de sua escolha na etapa anterior. Escolha uma zona ou região próxima a você, por exemplo, us-central1-a.
- Na lista suspensa, selecione uma das versões disponíveis como a versão do cluster do plano de controle.
Na seção Recursos, marque a caixa de seleção Ativar Cloud Run para Anthos.
Clique em Criar para criar e provisionar o cluster com a configuração que você acabou de concluir. Pode levar alguns instantes para que esse processo seja concluído.

Linha de comando

Para criar um novo cluster que ativa o Cloud Run para Anthos no Google Cloud:

Crie um novo cluster:
```
gcloud container clusters create CLUSTER-NAME \
--zone=ZONE \
--addons=HttpLoadBalancing,CloudRun \
--machine-type=n1-standard-2 \
--num-nodes=3 \
--cluster-version=GKE-VERSION \
--enable-stackdriver-kubernetes
```
- ZONEé a zona do Compute Engine desejada para o cluster.
- GKE-VERSION é a versão do GKE que você quer; Veja as versões disponíveis.
Essas instruções não permitirão o escalonamento automático de cluster para redimensionar clusters para demanda. O Cloud Run para Anthos no Google Cloud escalará automaticamente as instâncias no cluster.
Aguarde a conclusão da criação do cluster.

Como criar um cluster particular com o Cloud Run ativado

Por padrão, o cluster criado acima pode configurar o acesso dos pods a redes públicas. Se você quiser criar um cluster particular habilitado para o Cloud Run, que isole pods, nós e cargas de trabalho de conectividade com redes públicas, consulte as instruções a seguir. Caso contrário, pule para a próxima seção.

Os clientes externos ainda podem chamar o endereço IP do balanceador de carga externo do seu cluster particular. Para criar um cluster que nunca será exposto ao público, consulte Como configurar uma rede interna particular.

Crie um cluster particular com pelo menos quatro vCPUs.
Criar um cluster particular
Será possível pular estas instruções se você estiver usando o Cloud Run for Anthos em um Cluster do GKE com as versões a seguir:
- 1.16.8-gke.7+
- 1.15.11-gke.9+
Para implantar um serviço no Cloud Run para Anthos em um cluster particular do GKE, você precisa permitir conexões TCP de servidores do plano de controle (mestre) para nós na porta 8443 e especificar manualmente a porta 8443 na lista de conexões TCP permitidas editando as regras de firewall no projeto:
1. Visualize o bloco de CIDR do cluster do plano de controle e registre o valor no campo masterIpv4CidrBlock:
```
gcloud container clusters describe CLUSTER_NAME
```
2. Visualize e registre o valor no campo TARGET_TAGS:
```
gcloud compute firewall-rules list \
          --filter 'name~^gke-CLUSTER_NAME' \
           --format 'table(
                   name,
                   network,
                   direction,
                   sourceRanges.list():label=SRC_RANGES,
                   allowed[].map().firewall_rule().list():label=ALLOW,
                   targetTags.list():label=TARGET_TAGS
           )'
```
3. Adicione uma regra de firewall usando os valores registrados acima:
```
gcloud compute firewall-rules create FIREWALL_RULE_NAME \
     --action ALLOW \
     --direction INGRESS \
     --source-ranges masterIpv4CidrBlock \
     --rules tcp:8443 \
     --target-tags TARGET_TAGS
```
  Para mais informações, consulte Como criar regras de firewall.

Como configurar o gcloud para cluster e plataforma

Depois de criar o cluster,

Defina sua plataforma padrão como gke.
Se quiser, defina padrões para o nome do cluster e o local do cluster para evitar solicitações subsequentes quando você usar a linha de comando.
Receba credenciais que permitem que a linha de comando gcloud acesse seu cluster.

Para definir padrões:

Defina a plataforma padrão como gke, defina o cluster padrão e o local do cluster e receba as credenciais da seguinte maneira:
```
gcloud config set run/platform gke
gcloud config set run/cluster CLUSTER
gcloud config set run/cluster_location ZONE
gcloud container clusters get-credentials CLUSTER
```
Substitua:
- CLUSTER pelo nome do cluster;
- ZONE pelo local do cluster.
Os clusters do Kubernetes vêm com um namespace chamado default. Para informações sobre namespaces e por que convém criar e usar um namespace diferente de default, consulte namespace na documentação do Kubernetes. Para criar um novo namespace, execute:
```
kubectl create namespace NAMESPACE
```
Substitua NAMESPACE pelo namespace que você quer criar.
Se você tiver criado um novo namespace na etapa anterior e quiser usá-lo em vez do namespace default, defina esse novo namespace como o padrão a ser usado quando invocar a linha de comando gcloud:
```
gcloud config set run/namespace NAMESPACE
```

Como ativar métricas em um cluster com a identidade da carga de trabalho

Ao ativar a Identidade da carga de trabalho, o Cloud Run para Anthos não informa determinadas métricas, como contagem de solicitações de revisão ou latência de solicitação para o Pacote de operações do Google Cloud, mas continua a gerar relatórios de métricas de CPU e memória.

Se você quiser ativar todas as métricas, precisará definir manualmente as permissões para gravá-las no Cloud Monitoring. Para isso, conceda o papel de gravador da métrica do Monitoring à conta de serviço do Google (GSA, na sigla em inglês) associada ao serviço do Cloud Run para Anthos.

Conceda as permissões do papel de gravador de métricas do Monitoring à GSA do serviço:

gcloud projects add-iam-policy-binding PROJECT_ID 

  --member=serviceAccount:GSA_NAME@GSA_PROJECT.iam.gserviceaccount.com 

  --role=roles/monitoring.metricWriter

Substitua:

PROJECT_ID pelo ID de um projeto de cluster que hospeda sua KSA;
GSA_PROJECT pelo ID do projeto de uma GSA que não está no cluster. Use qualquer GSA na sua organização.

Para mais informações, consulte Como conceder, alterar e revogar o acesso aos recursos.

Para configurar os serviços fornecidos pelas APIs do Google Cloud, como as APIs Compute, Storage, Database ou Machine Learning dentro do seu Cluster do GKE, consulte Como usar a Identidade da carga de trabalho.

Como desenvolver uma configuração multilocatária

Em casos de uso multilocatários, você precisará gerenciar e implantar os serviços do Cloud Run para Anthos em um cluster do Google Kubernetes Engine que esteja fora do projeto atual. Nesta seção, ensinamos como desenvolver o Cloud Run para Anthos nos serviços do Google Cloud em uma configuração de cluster com vários locatários.

Para gerenciar e implantar os serviços do Cloud Run para Anthos em um cluster do Google Kubernetes Engine fora do projeto atual:

Verifique se você tem acesso de leitura ao ID do projeto do Google Cloud do cluster em que está implantando.
Atualize seu arquivo kubeconfig local com credenciais para o cluster de destino do GKE:
```
gcloud container clusters get-credentials NAME \
--region=REGION \
--project=PROJECT-ID
```
- REGION é a região do Compute Engine do cluster de destino.
- PROJECT-ID é o projeto ao qual você tem acesso de leitura.
Para mais informações, consulte a documentação de referência do comando gcloud container clusters get-credentials.
Use a linha de comando gcloud para se comunicar com o cluster do GKE definindo a plataforma padrão como kubernetes:
```
gcloud config set run/platform kubernetes
```

Agora é possível executar comandos no cluster de destino do GKE especificado no arquivo kubeconfig.

Por exemplo, o comando a seguir implantará um serviço do Cloud Run for Anthos usando uma imagem de contêiner especificada no Cluster do GKE com credenciais armazenadas no arquivo kubeconfig:

gcloud run deploy SERVICE-NAME --image IMAGE-NAME

Como configurar uma rede privada e interna

A implantação de serviços em uma rede interna é útil para empresas que fornecem aplicativos internos para a equipe e para serviços usados por clientes executados fora do Cloud Run para Anthos no cluster do Google Cloud. Essa configuração permite que outros recursos em sua rede se comuniquem com o serviço usando um endereço IP interno particular (RFC 1918) que não possa ser acessado pelo público.

Para criar sua rede interna, configure o gateway de entrada do Istio para usar balanceamento de carga TCP/UDP interno em vez de um balanceador de carga de rede externo e público. Em seguida, implante os serviços do Cloud Run para Anthos no Google Cloud em um endereço IP interno na rede VPC.

Antes de começar

Você precisa ter permissões admin no seu cluster.
Somente as versões 310.0 ou posteriores do SDK do Cloud são compatíveis. Para mais detalhes, consulte Como configurar o gcloud.

Para configurar o balanceador de carga interno:

Atualize o gateway de entrada do Istio para usar o balanceamento de carga TCP/UDP interno criando um novo cluster ou atualizando um atual:

Crie um novo cluster com um balanceador de carga interno:

gcloud container clusters create CLUSTER_NAME \
--addons=HttpLoadBalancing,CloudRun \
--machine-type=n1-standard-2  \
--num-nodes=3  \
--enable-stackdriver-kubernetes \
--cloud-run-config=load-balancer-type=INTERNAL

Atualize um cluster atual para usar um balanceador de carga interno:

gcloud container clusters update CLUSTER_NAME
--update-addons=CloudRun=ENABLED \
--cloud-run-config=load-balancer-type=INTERNAL

Pode levar alguns minutos para que a alteração entre em vigor.

Execute o seguinte comando para acompanhar as atualizações do cluster do GKE:
```
kubectl -n gke-system get svc istio-ingress --watch
```
1. Observe a anotação "cloud.google.com/load-balancer-type: Internal".
2. Procure o valor de IP no balanceador de carga do Entrada a fim de mudar para um endereço IP particular.
3. Pressione Ctrl+C para interromper as atualizações depois de ver um endereço IP particular no campo IP.

Para verificar a conectividade interna após as alterações:

Implante um serviço chamado sample no Cloud Run para Anthos no Google Cloud no namespace default:

gcloud run deploy sample \
--image gcr.io/knative-samples/simple-api \
--namespace default \
--platform gke

Crie uma máquina virtual (VM) do Compute Engine na mesma zona que o cluster do GKE:
```
VM=cloudrun-gke-ilb-tutorial-vm

gcloud compute instances create $VM
```
Armazene o endereço IP particular do gateway de entrada do Istio em uma variável de ambiente chamada EXTERNAL_IP e um arquivo chamado external-ip.txt:
```
export EXTERNAL_IP=$(kubectl -n gke-system get svc istio-ingress \
    -o jsonpath='{.status.loadBalancer.ingress[0].ip}' | tee external-ip.txt)
```
Copie o arquivo que contém o endereço IP da VM:
```
gcloud compute scp external-ip.txt $VM:~
```
Conecte-se à VM usando SSH:
```
gcloud compute ssh $VM
```

Durante a sessão SSH, teste o serviço de amostra:

curl -s -w'\n' -H Host:sample.default.example.com $(cat external-ip.txt)

A saída é a seguinte:

OK

Saia da sessão SSH:
```
exit
```

Como usar uma instalação separada do Istio

Nas instruções a seguir, mostramos como conectar o Anthos Service Mesh, o complemento Istio no GKE, ou uma instalação personalizada do Istio com o Cloud Run para Anthos, além dos componentes do Istio já instalados por padrão no Cloud Run para Anthos no Google Cloud.

No momento, os componentes do Istio, incluídos na instalação padrão do Cloud Run para Anthos no Google Cloud, não são compatíveis com a injeção automática de arquivo secundário. No entanto, é possível usar outra instalação do Istio para ativar a injeção de arquivo secundário do Istio para o namespace do serviço implantado.

Para usar outra instalação do Istio, é necessário verificar se o Gateway de entrada do Istio se chama istio-ingressgateway no namespace istio-system. O Cloud Run para Anthos é compatível e processa o tráfego externo dos gateways de entrada do Istio instalados em:

O namespace istio-system, com o domínio local do cluster istio-ingressgateway.istio-system.svc.cluster.local, que é configurado por padrão quando você usa outra instalação do Istio.
O namespace gke-system, com o domínio local do cluster istio-ingress.gke-system.svc.cluster.local configurado com a instalação padrão do Cloud Run para Anthos no Google Cloud.

Para verificar o outro gateway de entrada do Istio que o Cloud Run para Anthos usa:

Abra o ConfigMap config-istio:

kubectl get configmap config-istio --namespace knative-serving -oyaml

Verifique se o outro gateway de entrada do Istio se chama istio-ingressgateway e está no namespace istio-system.

Como ativar HTTPS e domínios personalizados

Se você quer usar domínios HTTPS e personalizados que se aplicam ao cluster, consulte Como ativar certificados HTTPS e TLS automático e mapear domínios personalizados.

Como desativar o Cloud Run para Anthos no Google Cloud

Para desativar o Cloud Run para Anthos no Google Cloud no cluster:

Acesse a página do Google Kubernetes Engine no Console do Cloud:

Acessar o Google Kubernetes Engine
Clique no cluster em que você quer desativar o Cloud Run para Anthos no Google Cloud.
Clique em Editar.
No menu suspenso Cloud Run para Anthos, selecione Desativar.
Clique em Salvar.