Como instalar o Anthos Service Mesh no local com um HSM e o Vault

Este guia explica como fazer uma instalação limpa da versão do Anthos Service Mesh 1.7.8-asm.10 em clusters do Anthos no VMware e usar o Thales Luna HSM 7+ e o Hashicorp Vault para gerar com segurança a chave de assinatura de CA do Istio e protegê-la.

Se você tiver uma versão anterior do Anthos Service Mesh instalada, consulte Como fazer upgrade do Anthos Service Mesh no GKE no VMware. A instalação ativa os recursos compatíveis no cluster para o perfil de configuração asm-multicloud.

Antes de começar

Confira os requisitos a seguir antes de iniciar a configuração.

Requisitos

  • Você precisa ter uma assinatura do Anthos. Como alternativa, uma opção de pagamento por utilização está disponível para o GKE Enterprise apenas no Google Cloud. Para mais informações, consulte o Guia de preços do GKE Enterprise.

  • Entre em contato com a equipe de suporte para conceder a você as permissões para acessar as imagens. A equipe de suporte também fornecerá assistência adicional.

  • Verifique se o cluster em que você instala o Anthos Service Mesh tem pelo menos quatro vCPUs, 15 GB de memória e quatro nós.

  • Você precisa nomear as portas de serviço usando a sintaxe a seguir: name: protocol[-suffix], em que os colchetes indicam um sufixo opcional que precisa começar com um traço. Saiba mais em Como nomear portas de serviço.

  • Verifique se a versão do cluster está listada em Ambientes compatíveis. Para verificar a versão do cluster, use a ferramenta de linha de comando gkectl. Se você não tiver a gkectl instalada, consulte Downloads do GKE On-Prem.

    gkectl version

  • É preciso ter o Thales Luna HSM 7+ na infraestrutura. O HSM precisa ter o serviço de rede configurado e acessível a partir do cluster do Anthos Service Mesh.

  • Você precisa ter servidores Hashicorp Vault na sua infraestrutura para armazenar as credenciais que acessam o HSM. Os servidores do Vault precisam ser acessados pelo cluster do Anthos Service Mesh por meio da rede.

Configurar o ambiente

Instale as ferramentas a seguir na máquina que você controla o processo de instalação do Anthos Service Mesh.

Após instalar as ferramentas de pré-requisito, execute as seguintes etapas:

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

    gcloud auth login

  2. Atualize os componentes:

    gcloud components update

  3. Instale kubectl:

    gcloud components install kubectl

  4. Para implantar e testar a instalação com o aplicativo de amostra Online Online (em inglês), instale kpt:

    gcloud components install kpt

  5. Alterne o contexto para o cluster de usuário (se necessário):

    kubectl config use-context CLUSTER_NAME

  6. Conceda permissões de administrador de cluster à sua conta de usuário (seu endereço de e-mail de login do Google Cloud). Você precisa dessas permissões para criar as regras necessárias de controle de acesso baseado em papéis (RBAC, na sigla em inglês) para o Anthos Service Mesh:

    kubectl create clusterrolebinding cluster-admin-binding \
  --clusterrole=cluster-admin \
  --user=USER_ACCOUNT

Implantar dependências

  • Implante o Thales Luna HSM 7+ na infraestrutura para gerenciar com segurança as chaves de assinatura de CA do Istio. Verifique se o HSM tem serviço de rede e conectividade com o cluster do Anthos Service Mesh.
  • Implante os servidores Hashicorp Vault na sua infraestrutura para armazenar as credenciais para acessar o HSM. Verifique se os servidores do Vault têm conectividade de rede com o cluster do Anthos Service Mesh.
  • Ter uma estação de trabalho com acesso ao servidor do Vault, ao HSM e ao cluster do Kubernetes em que você instala o Anthos Service Mesh.

Configurar o módulo de segurança de hardware (HSM)

Esta seção lista as etapas para configurar o módulo de segurança de hardware (HSM) e gerar chaves de criptografia.

Provisione as credenciais e o slot do HSM

Siga o guia de instalação de HSM para executar as etapas a seguir.

  1. Configure o HSM como um HSM de rede.

  2. Provisione arquivos PEM para conexões mTLS com o HSM, incluindo o arquivo de chave do cliente, o arquivo de certificado do cliente e o arquivo de certificado do servidor.

  3. Provisione um slot do HSM para o Anthos Service Mesh e registre o rótulo e o PIN do slot.

Gerar uma chave de criptografia de chaves (KEK) do HSM

  1. Na máquina com acesso ao HSM, faça o download da ferramenta HSM (disponível apenas para Linux amd-64).

    gsutil cp gs://artifacts.thalescpl-io-k8s-kms-plugin.appspot.com/binary/k8s-kms-plugin .

  2. Defina variáveis de ambiente antes de executar a ferramenta HSM como um servidor local, que se conecta ao HSM e é veiculado no Unix Domain Socket (UDS).

    export P11_TOKEN=HSM slot label
export ChrystokiConfigurationPath=path to the Thales HSM Chrystoki configuration file
export P11_LIB=path to the libCryptoki2.so file for accessing the Thales HSM
export P11_PIN_FILE=path to the file that stores the HSM slot PIN
export SOCKET=/tmp/.hsm-sock
./k8s-kms-plugin serve &

    A saída será semelhante a esta:

    The token has been initialized and is reassigned to slot 412789065
INFO Loaded P11 PIN from file: /home/hsm/hsm-credential/pin  line="cmd/serve.go:93"
INFO KMS Plugin Listening on : /var/.hsm-sock  line="cmd/serve.go:119"
INFO Serving on socket: /tmp/.hsm-sock  line="cmd/serve.go:198"

  3. Se você não tiver uma chave de criptografia de chaves (KEK, na sigla em inglês) no HSM, siga estas etapas para gerar uma. Use k8s-kms-plugin como um cliente para se comunicar com o servidor da ferramenta HSM. Se você quiser especificar explicitamente um ID KEK, transmita a sinalização --kek-id no comando. Caso contrário, um código KEK aleatório será gerado automaticamente.

    ./k8s-kms-plugin generate-kek --kek-id KEK ID

    Registre o código da KEK. Ele será usado nas etapas a seguir.

  4. O HSM usa o certificado raiz importado para verificar o certificado CA assinado do Istio. Você pode seguir este passo para importar o certificado raiz para o HSM. Use k8s-kms-plugin como um cliente para se comunicar com o servidor da ferramenta HSM. Importe o certificado raiz usando o comando a seguir.

    ./k8s-kms-plugin import-ca -f root cert PEM file

Configurar a autenticação do Kubernetes para o Vault

  1. No cluster do Kubernetes, crie uma conta de serviço dedicada e uma política de RBAC para que o Vault chame a API TokenReview. Crie um namespace dedicado para essa finalidade.

  2. Crie a conta de serviço padrão no namespace vault, defina as permissões e extraia o JSON Web Token (JWT) associado para o servidor do Vault chamar a API TokenReview do Kubernetes. Observação: você poderá usar qualquer conta de serviço e namespace do Kubernetes se tiver permissão suficiente.

  3. Configure o sufixo do cluster que você quer configurar. Use um diretório dedicado para a configuração.

    export CLUSTER_SUFFIX="c1"
mkdir ${CLUSTER_SUFFIX}
cd ${CLUSTER_SUFFIX}

  4. Alterne para o cluster que você quer gerenciar e crie o namespace vault. kubectl cria a conta de serviço padrão automaticamente.

    kubectl create ns vault

  5. Para conceder permissões, vincule a conta de serviço default.vault ao papel auth-delegator.

    kubectl apply -f -<< EOF
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
 name: role-tokenreview-binding
 namespace: vault
roleRef:
 apiGroup: rbac.authorization.k8s.io
 kind: ClusterRole
 name: system:auth-delegator
subjects:
 - kind: ServiceAccount
   name: default
   namespace: vault
EOF

  6. Crie um secret para armazenar a credencial do token.

    VAULT_SA_SECRET=default-token
kubectl apply -n vault -f - << EOF
apiVersion: v1
kind: Secret
metadata:
 name: "${VAULT_SA_SECRET}"
 annotations:
   kubernetes.io/service-account.name: default
type: kubernetes.io/service-account-token
EOF

  7. Receba o JWT para a conta de serviço default.vault.

    VAULT_SA_JWT_TOKEN=$(kubectl get -n vault secret $VAULT_SA_SECRET -o jsonpath="{.data.token}" | base64 --decode)
echo $VAULT_SA_JWT_TOKEN > ${CLUSTER_SUFFIX}-tokenreview_jwt
cat ${CLUSTER_SUFFIX}-tokenreview_jwt

  8. Recupere o endereço e o certificado de CA do servidor da API Kubernetes. Depois, configure o servidor do Vault para chamar o servidor da API Kubernetes.

  9. Receber os valores públicos de IP:Port do Kubernetes.

    K8S_ADDR=$(kubectl config  view -o jsonpath="{.clusters[?(@.name == '$(kubectl config current-context)')].cluster.server}")
echo $K8S_ADDR > ${CLUSTER_SUFFIX}-k8s_addr
cat ${CLUSTER_SUFFIX}-k8s_addr

  10. Receber o certificado para autenticar o servidor da API Kubernetes.

    VAULT_SA_CA_CRT=$(kubectl get -n vault secret $VAULT_SA_SECRET -o jsonpath="{.data['ca\.crt']}" | base64 --decode)
echo $VAULT_SA_CA_CRT > "${CLUSTER_SUFFIX}-k8s_cert"
cat "${CLUSTER_SUFFIX}-k8s_cert"

  11. Converta o arquivo de certificado no formato de arquivo PEM e valide-o.

    sed -i 's/ CERTIFICATE/CERTIFICATE/g' ${CLUSTER_SUFFIX}-k8s_cert
sed -i 's/ /\n/g' ${CLUSTER_SUFFIX}-k8s_cert
sed -i 's/CERTIFICATE/ CERTIFICATE/g' ${CLUSTER_SUFFIX}-k8s_cert

  12. Verifique se o certificado é válido.

    openssl x509 -in ${CLUSTER_SUFFIX}-k8s_cert -noout -text

  13. Volte para o diretório anterior.

    cd ..

Agora use os três arquivos no diretório do cluster para configurar o Vault na próxima etapa.

Configurar o Vault para armazenar credenciais do HSM

Quando o servidor do Vault estiver disponibilizando tráfego TLS com um certificado válido, configure o PKI do Vault e configure a autenticação do Kubernetes. Veja a seguir um exemplo de configuração de uma única CA raiz e CAs intermediárias por cluster.

  1. Faça login no Vault como raiz.

    vault login

  2. Armazene o secret do HSM.

    SECRET_PATH=asm-$CLUSTER_SUFFIX
vault secrets enable -path=$SECRET_PATH  kv
vault secrets tune -max-lease-ttl=87600h $SECRET_PATH
export HSM_SECRET_PATH="$SECRET_PATH/hsm"
vault kv put ${HSM_SECRET_PATH} clientcert=HSM_CLIENT_CERT clientkey=HSM_CLIENT_KEY servercert=HSM_SERVER_CERT PIN=HSM_PIN
vault kv get ${HSM_SECRET_PATH}

  3. Crie uma política com permissões para o caminho de ICP.

    vault policy write asm-$CLUSTER_SUFFIX-hsm-policy -<< EOF
path "${HSM_SECRET_PATH}" {
capabilities = ["read"]
}
EOF

  4. Adicione a autenticação do Kubernetes para o cluster.

    vault auth enable --path="${HSM_SECRET_PATH}"  kubernetes

  5. Defina o JWT do Kubernetes, o endereço do Kubernetes e o certificado de CA do Kubernetes no caminho de autenticação do Vault.

    vault write auth/${HSM_SECRET_PATH}/config \
token_reviewer_jwt=cat "${CLUSTER_SUFFIX}"-tokenreview_jwt \
kubernetes_host=cat "${CLUSTER_SUFFIX}"-k8s_addr \
kubernetes_ca_cert=@"${CLUSTER_SUFFIX}"-k8s_cert

  6. Permitir que istiod-service-account.istio-system autentique como papel demo e usar a política criada.

    vault write auth/${HSM_SECRET_PATH}/role/istiod \
bound_service_account_names=istiod-service-account \
bound_service_account_namespaces=istio-system \
policies=asm-$CLUSTER_SUFFIX-hsm-policy \
ttl=768h

  7. Volte para a pasta pai.

    cd ..

Fazer o download do arquivo de instalação

    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.7.8-asm.10-linux-amd64.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.7.8-asm.10-linux-amd64.tar.gz.1.sig
openssl dgst -verify /dev/stdin -signature istio-1.7.8-asm.10-linux-amd64.tar.gz.1.sig istio-1.7.8-asm.10-linux-amd64.tar.gz <<'EOF'
-----BEGIN PUBLIC KEY-----
MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWZrGCUaJJr1H8a36sG4UUoXvlXvZ
wQfk16sxprI2gOJ2vFFggdq3ixF2h4qNBt0kI7ciDhgpwS8t+/960IsIgw==
-----END PUBLIC KEY-----
EOF

    A saída esperada é Verified OK.

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

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

    • Exemplos de aplicativos no diretório samples.
    • A ferramenta de linha de comando istioctl usada para instalar o Anthos Service Mesh está no diretório bin.
    • Os perfis de configuração do Anthos Service Mesh estão no diretório install/kubernetes/operator/profiles.

    4. macOS

  4. Faça o download do arquivo de instalação do Anthos Service Mesh no diretório de trabalho atual: 
    curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.7.8-asm.10-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.7.8-asm.10-osx.tar.gz.1.sig
openssl dgst -sha256 -verify /dev/stdin -signature istio-1.7.8-asm.10-osx.tar.gz.1.sig istio-1.7.8-asm.10-osx.tar.gz <<'EOF'
-----BEGIN PUBLIC KEY-----
MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWZrGCUaJJr1H8a36sG4UUoXvlXvZ
wQfk16sxprI2gOJ2vFFggdq3ixF2h4qNBt0kI7ciDhgpwS8t+/960IsIgw==
-----END PUBLIC KEY-----
EOF

    A saída esperada é Verified OK.

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

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

    • Exemplos de aplicativos no diretório samples.
    • A ferramenta de linha de comando istioctl usada para instalar o Anthos Service Mesh está no diretório bin.
    • Os perfis de configuração do Anthos Service Mesh estão no diretório install/kubernetes/operator/profiles.

    7. Windows

  7. Faça o download do arquivo de instalação do Anthos Service Mesh no diretório de trabalho atual: 
    curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.7.8-asm.10-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.7.8-asm.10-win.zip.1.sig
openssl dgst -verify - -signature istio-1.7.8-asm.10-win.zip.1.sig istio-1.7.8-asm.10-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.7.8-asm.10-win.zip

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

    • Exemplos de aplicativos no diretório samples.
    • A ferramenta de linha de comando istioctl usada para instalar o Anthos Service Mesh está no diretório bin.
    • Os perfis de configuração do Anthos Service Mesh estão no diretório install/kubernetes/operator/profiles.

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

Configurar o recurso no plano de controle

  1. Defina as variáveis de ambiente.

    export CLUSTER_SUFFIX="c1"
export VAULT_ADDR="https://VAULT_IP:PORT"

  2. Copie o arquivo que contém o certificado para autenticar o Vault em um arquivo chamado cert. Por exemplo, o certificado TLS do servidor do Vault, ${VAULT_CACERT}.

    cp ${VAULT_CACERT} ./cert

  3. Crie um ConfigMap a partir do arquivo no namespace istio-system.

    kubectl create ns istio-system
kubectl delete configmap vault-tls-cert -n istio-system
kubectl create configmap vault-tls-cert -n istio-system --from-file=./cert

Configurar o webhook de validação

Ao instalar o Anthos Service Mesh, você define um rótulo de revisão em istiod. Você precisa definir a mesma revisão no webhook de validação.

Copie o seguinte YAML para um arquivo chamado istiod-service.yaml.

apiVersion: v1
kind: Service
metadata:
  name: istiod
  namespace: istio-system
  labels:
    istio.io/rev: asm-178-10
    app: istiod
    istio: pilot
    release: istio
spec:
  ports:
    - port: 15010
      name: grpc-xds # plaintext
      protocol: TCP
    - port: 15012
      name: https-dns # mTLS with k8s-signed cert
      protocol: TCP
    - port: 443
      name: https-webhook # validation and injection
      targetPort: 15017
      protocol: TCP
    - port: 15014
      name: http-monitoring # prometheus stats
      protocol: TCP
  selector:
    app: istiod
    istio.io/rev: asm-178-10

Instale o Anthos Service Mesh

  1. Configure as variáveis de ambiente para configurar o ASM para interagir com o Vault e o HSM. O comando a seguir reduz o tempo de espera para 10 segundos porque o Istio não estará totalmente pronto devido à operação de importação pendente pelo operador.

    export HSM_SLOT_LABEL=the HSM slot label
export VAULT_ADDR=address of the vault server
export HSM_SECRET_PATH=the path to the HSM secret on Vault
export KEK_ID=the HSM slot KEK ID
export HSM_PLUGIN_IMAGE=gcr.io/thalescpl-io-k8s-kms-plugin/hsm-plugin:asm-1.7-1
export VAULT_CLIENT_IMAGE=gcr.io/gke-release/asm/vaultclient:latest
export WAIT_FOR_RESOURCES_TIMEOUT=10s

  2. Execute o seguinte comando para instalar o Anthos Service Mesh com o perfil asm-multicloud. Se você quiser ativar um recurso opcional compatível, inclua -f e o nome de arquivo YAML na linha de comando a seguir. Para mais informações, consulte Como ativar recursos opcionais.

    istioctl install --set profile=asm-multicloud \
   --set revision=asm-178-10 \
   --set values.hsm.enabled=true \
   --set values.hsm.hsmKEKID=${KEK_ID} \
   --set values.hsm.hsmPluginImage=${HSM_PLUGIN_IMAGE} \
   --set values.hsm.hsmSlotLabel=${HSM_SLOT_LABEL} \
   --set values.hsm.vaultClientImage=${VAULT_CLIENT_IMAGE} \
   --set values.hsm.vaultAddr=${VAULT_ADDR} \
   --set values.hsm.vaultAuthPath=auth/${HSM_SECRET_PATH}/login \
   --set values.hsm.vaultAuthRole=istiod \
   --set values.hsm.vaultAuthJwtPath="/var/run/secrets/kubernetes.io/serviceaccount/token" \
   --set values.hsm.vaultSecretPath=${HSM_SECRET_PATH} \
   --set values.global.jwtPolicy="first-party-jwt"

  3. Configure o webhook de validação para que ele possa localizar o serviço istiod com o rótulo de revisão:

    kubectl apply -f istiod-service.yaml

    Esse comando cria uma entrada de serviço que permite ao webhook de validação verificar automaticamente as configurações antes de serem aplicadas.

  4. Verifique se o Istio foi inicializado corretamente e está em espera.

    kubectl get pod -l app=istiod -n istio-system

    A saída será semelhante a esta:

    NAME                      READY   STATUS    RESTARTS   AGE
istiod-66ff56d76c-f9p5l   2/3     Running   2          1m27s

    Veja que o Istio não está totalmente pronto porque o contêiner discovery está bloqueado e aguardando o certificado.

  5. Verifique o registro dos contêineres do Istio para garantir que eles estão no estado certo.

    kubectl logs -c hsm-plugin -l app=istiod -n istio-system

    A saída será semelhante a esta:

    The token has been initialized and is reassigned to slot 412789065
INFO Loaded P11 PIN from file: /var/run/hsm-credential/pin  line="cmd/serve.go:93"
INFO KMS Plugin Listening on : /var/run/hsm-socket/.sock  line="cmd/serve.go:119"
INFO Serving on socket: /var/run/hsm-socket/.sock  line="cmd/serve.go:198"
KEK ID: 7651a4ea-eeb7-4c1f-927b-8c871c2127aa
    kubectl logs -c discovery -l app=istiod -n istio-system

    Espere a última linha de saída, como a seguinte:

    ...
2020-10-15T21:56:56.918931Z info    pkica   Wait until the CA certificate secret istio-system.istio-ca-cert can be loaded...

Assinar certificado para o Istio

  1. Faça o download da CSR criptografada pelo secret do Kubernetes.

    kubectl get secret istio-ca-cert-csr -n istio-system -o jsonpath={.data} > encrypted_csr.json

  2. Descriptografe a CSR.

    kubectl get secret istio-ca-cert-csr -n istio-system -o jsonpath={.data} > encrypted_csr.json
./k8s-kms-plugin decrypt-csr -f encrypted_csr.json -o csr.pem

  3. O administrador de segurança precisa assinar o arquivo csr.pem usando a CA raiz.

  4. Coloque a cadeia de certificados na raiz do arquivo chamado cert-chain.pem e execute o comando a seguir.

    kubectl create secret generic istio-ca-cert --from-file=cert-chain.pem -n istio-system

  5. Verifique no Istio se a Istio está carregando a nova cadeia de certificados.

    kubectl logs ISTIOD_POD -c discovery -n istio-system | grep "CA cert\:" -A 60

    A resposta será semelhante a esta:

    2020-10-24T18:58:14.354254Z info    pkica   CA cert:
-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----

certificados intermediários: -----BEGIN CERTIFICATE----- ... -----END CERTIFICATE-----

certificado raiz: -----BEGIN CERTIFICATE----- ... -----END CERTIFICATE-----

Verificar a instalação

Siga as etapas abaixo para verificar se a instalação do Anthos Service Mesh está funcionando corretamente.

Verificar os componentes do plano de controle

  1. Verifique se os pods do plano de controle em istio-system estão em execução:

    kubectl get pod -n istio-system

    A saída esperada será assim:

    NAME                                      READY   STATUS      RESTARTS   AGE
istio-ingressgateway-74cc894bfd-786rg     1/1     Running     0          7m19s
istiod-78cdbbbdb-d7tps                    3/3     Running     0          7m36s
promsd-576b8db4d6-lqf64                   2/2     Running     1          7m19s

  2. Acione uma chamada TLS para um serviço do arquivo secundário e inspecione o certificado usado pelo serviço, usando bookinfo como exemplo.

    kubectl exec POD -c istio-proxy -- openssl s_client -alpn istio -showcerts -connect details:9080

    Inspecione os certificados na saída e espere ver a cadeia de certificados do lado do servidor na saída.

Injetar proxies de arquivo secundário

O Anthos Service Mesh usa proxies sidecar para aumentar a segurança, a confiabilidade e a observabilidade da rede. Com o Anthos Service Mesh, essas funções são abstraídas do contêiner principal do aplicativo e implementadas em um proxy comum fora do processo, entregue como um contêiner separado no mesmo pod. Para injetar seus pods com o proxy sidecar, configure a injeção automática de proxy sidecar (injeção automática) rotulando seus namespaces com o mesmo rótulo de revisão definido em istiod ao instalar o Anthos Service Mesh.

  • Você precisa ativar a injeção automática em qualquer namespace com cargas de trabalho em execução no cluster antes de instalar o Anthos Service Mesh.

  • Antes de implantar novas cargas de trabalho, configure a injeção automática para que o Anthos Service Mesh possa monitorar e proteger o tráfego.

Para ativar a injeção automática:

  1. Use o seguinte comando para localizar o rótulo de revisão em istiod:

    kubectl -n istio-system get pods -l app=istiod --show-labels

    A resposta será semelhante a:

    NAME                                READY   STATUS    RESTARTS   AGE   LABELS
istiod-asm-178-10-5788d57586-bljj4   1/1     Running   0          23h   app=istiod,istio.io/rev=asm-178-10,istio=istiod,pod-template-hash=5788d57586
istiod-asm-178-10-5788d57586-vsklm   1/1     Running   1          23h   app=istiod,istio.io/rev=asm-178-10,istio=istiod,pod-template-hash=5788d57586

    Na saída, na coluna LABELS, observe o valor do rótulo de revisão istiod, que segue o prefixo istio.io/rev=. Neste exemplo, o valor é asm-178-10.

  2. Aplique o rótulo de revisão e remova o rótulo istio-injection, se ele existir. No comando a seguir, NAMESPACE é o nome do namespace em que você quer ativar a injeção automática, e REVISION é o rótulo de revisão que você anotou na etapa anterior.

    kubectl label namespace NAMESPACE istio-injection-istio.io/rev=REVISION --overwrite

    Você pode ignorar a mensagem "istio-injection not found" na saída. Isso significa que o namespace não tinha o rótulo istio-injection anteriormente, que é esperado em novas instalações do Anthos Service Mesh ou em novas implantações. Como a injeção automática falha se um namespace tiver o istio-injection e o rótulo de revisão, todos os comandos kubectl label na documentação do Anthos Service Mesh incluem a remoção do rótulo istio-injection.

  3. Se as cargas de trabalho estavam em execução no cluster antes de instalar o Anthos Service Mesh, reinicie os pods para acionar a nova injeção.

    A maneira como você reinicia os pods depende do seu aplicativo e do ambiente em que o cluster está. Por exemplo, no seu ambiente de preparo, basta excluir todos os pods, o que faz com que eles sejam reiniciados. Mas no ambiente de produção, há um processo que implementa uma implantação azul-verde para que você possa reiniciar os pods com segurança para evitar a interrupção do tráfego.

    É possível usar kubectl para executar uma reinicialização gradual:

    kubectl rollout restart deployment -n NAMESPACE

  4. Verifique se os pods estão configurados para apontar para a nova versão de istiod.

    kubectl get pods -n NAMESPACE -l istio.io/rev=REVISION

Configurar um endereço IP externo

A instalação padrão do Anthos Service Mesh presume que um endereço IP externo é alocado automaticamente para serviços LoadBalancer. Isso não é verdade no GKE no VMware. Por isso, é preciso alocar manualmente um endereço IP para o recurso de gateway de entrada do Anthos Service Mesh.

Para configurar um endereço IP externo, siga uma das seções abaixo, dependendo do modo de balanceamento de carga do cluster:

Configurar o modo de balanceamento de carga integrado

  1. Abra a configuração do serviço istio-ingressgateway:

    kubectl edit svc -n istio-system istio-ingressgateway

    A configuração do serviço istio-ingressgateway é aberta no editor de texto padrão do shell.

  2. No arquivo, adicione a seguinte linha no bloco de especificação (spec):

    loadBalancerIP: <your static external IP address>

    Exemplo:

    spec:
 loadBalancerIP: 203.0.113.1

  3. Salve o arquivo.

Configurar o modo de balanceamento de carga manual

Para expor um serviço do tipo NodePort com um endereço IP virtual (VIP) no seu balanceador de carga, consiga os valores nodePort primeiro:

  1. Veja a configuração do serviço istio-ingressgateway no shell:

    kubectl get svc -n istio-system istio-ingressgateway -o yaml

    Cada uma das portas dos gateways do Anthos Service Mesh é exibida. A resposta ao comando será semelhante à seguinte:

     ...
 ports:
 - name: status-port
   nodePort: 30391
   port: 15020
   protocol: TCP
   targetPort: 15020
 - name: http2
   nodePort: 31380
   port: 80
   protocol: TCP
   targetPort: 80
 - name: https
   nodePort: 31390
   port: 443
   protocol: TCP
   targetPort: 443
 - name: tcp
   nodePort: 31400
   port: 31400
   protocol: TCP
   targetPort: 31400
 - name: https-kiali
   nodePort: 31073
   port: 15029
   protocol: TCP
   targetPort: 15029
 - name: https-prometheus
   nodePort: 30253
   port: 15030
   protocol: TCP
   targetPort: 15030
 - name: https-grafana
   nodePort: 30050
   port: 15031
   protocol: TCP
   targetPort: 15031
 - name: https-tracing
   nodePort: 31204
   port: 15032
   protocol: TCP
   targetPort: 15032
 - name: tls
   nodePort: 30158
   port: 15443
   protocol: TCP
   targetPort: 15443
 ...

  2. Exponha essas portas pelo balanceador de carga.

    Por exemplo, a porta de serviço chamada http2 tem port 80 e nodePort 31380. Suponha que os endereços de nó do cluster de usuário sejam 192.168.0.10, 192.168.0.11 e 192.168.0.12, e o VIP do balanceador de carga seja 203.0.113.1.

    Configure o balanceador de carga para que o tráfego enviado para 203.0.113.1:80 seja encaminhado para 192.168.0.10:31380, 192.168.0.11:31380 ou 192.168.0.12:31380. É possível selecionar as portas de serviço que quer expor nesse VIP.

A seguir