Installa Anthos Service Mesh on-premise con un HSM e Vault

Questa guida spiega come installare Anthos Service Mesh su GKE esistente su VMware e utilizzare Thales Luna HSM 7+ e Hashicorp Vault per generare in modo sicuro la chiave di firma CA di Istiod e proteggere la chiave di firma CA.

Se hai installato una versione precedente di Anthos Service Mesh, consulta l'articolo sull'upgrade di Anthos Service Mesh GKE su VMware. Questa installazione abilita le funzionalità supportate sul tuo cluster.

Prima di iniziare

Esamina i seguenti requisiti prima di iniziare la configurazione.

Requisiti

• Devi avere una sottoscrizione ad Anthos. In alternativa, per GKE Enterprise è disponibile l'opzione di fatturazione con pagamento a consumo solo su Google Cloud. Per ulteriori informazioni, consulta la guida ai prezzi di GKE Enterprise.

• Devi contattare il team di assistenza affinché ti conceda le autorizzazioni per accedere alle immagini. Il team di assistenza ti fornirà anche ulteriore supporto.

• Verifica che il cluster in cui installi Anthos Service Mesh abbia almeno 4 vCPU, 15 GB di memoria e 4 nodi.

• Devi assegnare un nome alle porte di servizio utilizzando la seguente sintassi: name: protocol[-suffix] dove le parentesi quadre indicano un suffisso facoltativo che deve iniziare con un trattino. Per maggiori informazioni, consulta Denominazione delle porte dei servizi.

• Verifica che la versione del cluster sia elencata in Ambienti supportati. Per verificare la versione del cluster, puoi utilizzare lo strumento a riga di comando gkectl. Se non hai installato gkectl, vedi Download di GKE on-prem.

  gkectl version

• Nella tua infrastruttura dovresti disporre di Thales Luna HSM 7 o versioni successive. HSM deve avere un servizio di rete configurato e raggiungibile dal cluster Anthos Service Mesh.

• Devi disporre di server Hashicorp Vault nella tua infrastruttura per archiviare le credenziali per accedere all'HSM. I server Vault dovrebbero essere raggiungibili dal cluster Anthos Service Mesh attraverso la rete.

Configura l'ambiente

Installa i seguenti strumenti sulla macchina da cui controlli il processo di installazione di Anthos Service Mesh.

Nota: puoi installare Anthos Service Mesh solo su un cluster utente, non su un cluster di amministrazione.

• Lo strumento a riga di comando curl.
• Google Cloud CLI.

Dopo aver installato gli strumenti prerequisiti, procedi nel seguente modo:

1. Esegui l'autenticazione con gcloud CLI:

   gcloud auth login --project PROJECT_ID
   

2. Aggiorna i componenti:

   gcloud components update
   

3. Installa kubectl:

   gcloud components install kubectl
   

4. Per eseguire il deployment e testare l'installazione con l'applicazione di esempio Online Boutique, installa kpt:

   gcloud components install kpt
   

5. Cambia il contesto nel tuo cluster utente (se necessario):

   kubectl config use-context CLUSTER_NAME

6. Concedi le autorizzazioni di amministratore del cluster al tuo account utente (l'indirizzo email di accesso a Google Cloud). Devi disporre di queste autorizzazioni per creare le regole di controllo dell'controllo dell'accesso basato sui ruoli (RBAC) necessarie per Anthos Service Mesh:

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

Esegui il deployment delle dipendenze

• Esegui il deployment di Thales Luna HSM 7 o versioni successive nella tua infrastruttura per gestire in modo sicuro le chiavi di firma della CA Istiod. Assicurati che HSM disponga del servizio di rete e della connettività con il cluster Anthos Service Mesh.
• Esegui il deployment dei server Hashicorp Vault nella tua infrastruttura per archiviare le credenziali di accesso all'HSM. Assicurati che i server Vault dispongano della connettività di rete con il cluster Anthos Service Mesh.
• Disporre di una workstation con accesso al server Vault, a HSM e al cluster Kubernetes su cui installi Anthos Service Mesh.

Configurare il modulo di sicurezza hardware (HSM)

In questa sezione sono elencati i passaggi per configurare il modulo di sicurezza hardware (HSM) e generare chiavi di crittografia.

Esegui il provisioning delle credenziali e dello slot HSM

Segui la guida all'installazione di HSM per eseguire la procedura riportata di seguito.

1. Configurare l'HSM come HSM di rete.

2. Esegui il provisioning di file PEM per le connessioni mTLS con l'HSM, inclusi i file delle chiavi client, dei certificati client e dei certificati server.

3. Esegui il provisioning di uno slot HSM per Anthos Service Mesh e registra l'etichetta e il PIN dello slot.

Generazione di una chiave di crittografia della chiave HSM (KEK)

1. Sulla macchina con accesso all'HSM, scarica lo strumento HSM (disponibile solo per Linux amd-64).

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

2. Imposta le variabili di ambiente prima di eseguire lo strumento HSM come server locale, che si connette all'HSM e gestisce il socket di dominio Unix (UDS) locale.

   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 &

   È previsto un output simile al seguente:

   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 non disponi di una chiave di crittografia della chiave (KEK) sull'HSM, segui questi passaggi per generarne una. Utilizza k8s-kms-plugin come client per comunicare con il server degli strumenti HSM. Se vuoi specificare esplicitamente un ID KEK, puoi passare il flag --kek-id nel comando. In caso contrario, verrà generato automaticamente un ID KEK casuale.

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

   Registra l'ID KEK. Lo utilizzerai nei passaggi seguenti.

4. HSM utilizza il certificato radice importato per verificare il certificato CA Istiod firmato. Puoi seguire questo passaggio per importare il certificato radice in HSM. Utilizza k8s-kms-plugin come client per comunicare con il server degli strumenti HSM. Importa il certificato radice utilizzando il comando seguente.

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

Configura l'autenticazione di Kubernetes per Vault

1. Nel cluster Kubernetes, crea un account di servizio dedicato e un criterio RBAC affinché Vault possa chiamare l'API TokenReview. Crea uno spazio dei nomi dedicato a questo scopo.

2. Crea l'account di servizio predefinito nello spazio dei nomi vault, imposta le autorizzazioni ed estrai il token JWT (JSON Web Token) associato per fare in modo che il server Vault chiami l'API Kubernetes TokenReview. Nota: puoi utilizzare qualsiasi account di servizio e spazi dei nomi Kubernetes se dispongono di autorizzazioni sufficienti.

3. Configura il suffisso per il cluster che vuoi configurare. Utilizza una directory dedicata per la configurazione.

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

4. Passa al cluster che vuoi gestire e crea lo spazio dei nomi vault. kubectl crea automaticamente l'account di servizio predefinito.

   kubectl create ns vault
   

5. Per concedere le autorizzazioni, associa l'account di servizio default.vault al ruolo 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. Crea un secret per conservare la credenziale del 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. Scarica il JWT per l'account di servizio 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. Recupera l'indirizzo e il certificato CA del server API Kubernetes. Successivamente, configura il server Vault in modo che chiami il server API Kubernetes.

9. Recupera i valori IP:Port pubblici di 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. Recupera il certificato per l'autenticazione del server 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. Converti il file del certificato nel formato file PEM e convalidalo.

    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. Verifica che il certificato sia valido.

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

13. Torna alla directory precedente.

    cd ..
    

Importante: ripeti i passaggi precedenti per ogni cluster nel tuo mesh.

Ora utilizza i tre file nella directory del cluster per configurare Vault nel passaggio successivo.

Configurazione di Vault per l'archiviazione delle credenziali HSM

Quando il server Vault gestisce il traffico TLS con un certificato valido, configura l'infrastruttura a chiave pubblica di Vault e configura l'autenticazione di Kubernetes. Di seguito è riportato un esempio di configurazione di una singola CA radice e di CA intermedie per cluster.

1. Accedi a Vault come root.

   vault login
   

2. Archivia il secret per 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. Crea un criterio con autorizzazioni per il percorso dell'infrastruttura a chiave pubblica.

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

4. Aggiungi l'autenticazione Kubernetes per il cluster.

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

5. Imposta il JWT di Kubernetes, l'indirizzo Kubernetes e il certificato CA di Kubernetes nel percorso di autenticazione di 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. Consenti a istiod-service-account.istio-system di eseguire l'autenticazione come ruolo demo e di utilizzare il criterio creato.

   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. Torna alla cartella principale.

   cd ..
   

Scarica il file di installazione

Linux

1. Scarica il file di installazione di Anthos Service Mesh nella tua directory di lavoro attuale:

   curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.10.6-asm.2-linux-amd64.tar.gz

2. Scarica il file della firma e utilizza openssl per verificare la firma:

   curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.10.6-asm.2-linux-amd64.tar.gz.1.sig
   openssl dgst -verify /dev/stdin -signature istio-1.10.6-asm.2-linux-amd64.tar.gz.1.sig istio-1.10.6-asm.2-linux-amd64.tar.gz <<'EOF'
   -----BEGIN PUBLIC KEY-----
   MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWZrGCUaJJr1H8a36sG4UUoXvlXvZ
   wQfk16sxprI2gOJ2vFFggdq3ixF2h4qNBt0kI7ciDhgpwS8t+/960IsIgw==
   -----END PUBLIC KEY-----
   EOF

   L'output previsto è: Verified OK.

3. Estrai i contenuti del file in qualsiasi posizione nel file system. Ad esempio, per estrarre i contenuti nella directory di lavoro corrente:

    tar xzf istio-1.10.6-asm.2-linux-amd64.tar.gz

   Il comando crea una directory di installazione nella directory di lavoro corrente denominata istio-1.10.6-asm.2 che contiene:

   • Applicazioni di esempio nella directory samples.
   • Lo strumento a riga di comando istioctl che utilizzi per installare Anthos Service Mesh si trova nella directory bin.
   • I profili di configurazione di Anthos Service Mesh si trovano nella directory manifests/profiles.

4. Assicurati di essere nella directory principale dell'installazione di Anthos Service Mesh.

   cd istio-1.10.6-asm.2

Mac OS

1. Scarica il file di installazione di Anthos Service Mesh nella directory di lavoro attuale:

   curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.10.6-asm.2-osx.tar.gz

2. Scarica il file della firma e utilizza openssl per verificare la firma:

   curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.10.6-asm.2-osx.tar.gz.1.sig
   openssl dgst -sha256 -verify /dev/stdin -signature istio-1.10.6-asm.2-osx.tar.gz.1.sig istio-1.10.6-asm.2-osx.tar.gz <<'EOF'
   -----BEGIN PUBLIC KEY-----
   MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWZrGCUaJJr1H8a36sG4UUoXvlXvZ
   wQfk16sxprI2gOJ2vFFggdq3ixF2h4qNBt0kI7ciDhgpwS8t+/960IsIgw==
   -----END PUBLIC KEY-----
   EOF

   L'output previsto è: Verified OK.

3. Estrai i contenuti del file in qualsiasi posizione nel file system. Ad esempio, per estrarre i contenuti nella directory di lavoro corrente:

   tar xzf istio-1.10.6-asm.2-osx.tar.gz

   Il comando crea una directory di installazione nella directory di lavoro corrente denominata istio-1.10.6-asm.2 che contiene:

   • Applicazioni di esempio nella directory samples.
   • Lo strumento a riga di comando istioctl che utilizzi per installare Anthos Service Mesh si trova nella directory bin.
   • I profili di configurazione di Anthos Service Mesh si trovano nella directory manifests/profiles.

4. Assicurati di essere nella directory principale dell'installazione di Anthos Service Mesh.

   cd istio-1.10.6-asm.2

Windows

1. Scarica il file di installazione di Anthos Service Mesh nella directory di lavoro attuale:

   curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.10.6-asm.2-win.zip

2. Scarica il file della firma e utilizza openssl per verificare la firma:

   curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.10.6-asm.2-win.zip.1.sig
   openssl dgst -verify - -signature istio-1.10.6-asm.2-win.zip.1.sig istio-1.10.6-asm.2-win.zip <<'EOF'
   -----BEGIN PUBLIC KEY-----
   MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEWZrGCUaJJr1H8a36sG4UUoXvlXvZ
   wQfk16sxprI2gOJ2vFFggdq3ixF2h4qNBt0kI7ciDhgpwS8t+/960IsIgw==
   -----END PUBLIC KEY-----
   EOF

   L'output previsto è: Verified OK.

3. Estrai i contenuti del file in qualsiasi posizione nel file system. Ad esempio, per estrarre i contenuti nella directory di lavoro corrente:

   tar xzf istio-1.10.6-asm.2-win.zip

   Il comando crea una directory di installazione nella directory di lavoro corrente denominata istio-1.10.6-asm.2 che contiene:

   • Applicazioni di esempio nella directory samples.
   • Lo strumento a riga di comando istioctl che utilizzi per installare Anthos Service Mesh si trova nella directory bin.
   • I profili di configurazione di Anthos Service Mesh si trovano nella directory manifests/profiles.

4. Assicurati di essere nella directory principale dell'installazione di Anthos Service Mesh.

   cd istio-1.10.6-asm.2

Configura la risorsa nel piano di controllo

1. Imposta le variabili di ambiente.

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

2. Copia il file contenente il certificato per l'autenticazione di Vault in un file denominato cert. Ad esempio, il certificato TLS del server Vault, ${VAULT_CACERT}.

   Nota: il client Vault utilizza questo certificato per autenticare il server Vault. Questo certificato è diverso da quello utilizzato da Vault per autenticare il server API Kubernetes.

   cp ${VAULT_CACERT} ./cert
   

3. Crea un ConfigMap dal file nello spazio dei nomi 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
   

Configura il webhook di convalida

Quando installi Anthos Service Mesh, imposti un'etichetta di revisione su istiod. Devi impostare la stessa revisione sul webhook di convalida.

Copia il seguente file YAML in un file denominato istiod-service.yaml:

apiVersion: v1
kind: Service
metadata:
  name: istiod
  namespace: istio-system
  labels:
    istio.io/rev: asm-1106-2
    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-1106-2

Installazione di Anthos Service Mesh

1. Imposta le variabili di ambiente per configurare ASM per l'interazione con Vault e HSM. Il comando seguente riduce il tempo di attesa a 10 secondi, perché Istiod non sarà completamente pronto a causa dell'operazione di importazione in attesa da parte dell'operatore.

   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. Esegui questo comando per installare Anthos Service Mesh utilizzando il profilo asm-multicloud. Se vuoi abilitare una funzionalità facoltativa supportata, includi -f e il nome del file YAML nella riga di comando seguente. Per ulteriori informazioni, consulta Attivazione delle funzionalità facoltative.

   istioctl install --set profile=asm-multicloud \
      --set revision=asm-1106-2 \
      --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. Configura il webhook di convalida in modo che possa individuare il servizio istiod con l'etichetta di revisione:

   kubectl apply -f istiod-service.yaml
   

   Questo comando crea una voce di servizio che consente al webhook di convalida di controllare automaticamente le configurazioni prima che vengano applicate.

4. Verifica che Istiod sia inizializzato correttamente e che sia in stato di attesa.

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

   Aspettati un output simile al seguente:

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

   Controlla che Istiod non è completamente pronto perché il container discovery è bloccato e in attesa del certificato.

5. Controlla il log dei container Istiod per assicurarti che siano nello stato corretto.

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

   Aspettati un output simile al seguente:

   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

   L'ultima riga di output dovrebbe essere simile alla seguente:

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

Firma il certificato per Istiod

1. Scarica il CSR criptato dal secret di Kubernetes.

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

2. Decripta la 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. L'amministratore della sicurezza deve prendere il file csr.pem e firmarlo utilizzando l'autorità di certificazione principale.

4. Inserisci la catena di certificati nella directory principale del file denominato cert-chain.pem, quindi esegui questo comando.

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

5. Verifica che Istiod carichi la nuova catena di certificati correttamente ispezionando il log Istiod.

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

   L'output dovrebbe essere simile al seguente:

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

certificati intermedi: -----BEGIN CERTIFICATE----- ... -----END CERTIFICATE-----

certificato radice: -----BEGIN CERTIFICATE----- ... -----END CERTIFICATE-----

Verifica l'installazione

Segui questi passaggi per verificare il corretto funzionamento dell'installazione di Anthos Service Mesh.

Controlla i componenti del piano di controllo

1. Verifica che i pod del piano di controllo in istio-system siano in esecuzione:

   kubectl get pod -n istio-system

   L'output previsto è simile al seguente:

   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

   Nota: l'avvio dei server potrebbe richiedere del tempo. Se non vedi l'output previsto, attendi qualche minuto e ricontrolla.

2. Attiva una chiamata TLS a un servizio dal file collaterale e controlla il certificato utilizzato dal servizio, utilizzando bookinfo come esempio.

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

   Controlla i certificati nell'output e aspettati di vedere la catena di certificati lato server nell'output.

Inserimento di proxy sidecar

Anthos Service Mesh utilizza i proxy sidecar per migliorare la sicurezza, l'affidabilità e l'osservabilità della rete. Con Anthos Service Mesh, queste funzioni vengono astratte dal container principale dell'applicazione e implementate in un proxy out-of-process comune, fornito come container separato nello stesso pod.

L'installazione non è completa finché non attivi l'inserimento automatico del proxy sidecar (inserimento automatico) e riavvii i pod per qualsiasi carico di lavoro in esecuzione sul tuo cluster prima dell'installazione di Anthos Service Mesh.

Per abilitare l'inserimento automatico, etichetta gli spazi dei nomi con l'etichetta di revisione che è stata impostata il giorno istiod al momento dell'installazione di Anthos Service Mesh. L'etichetta di revisione viene utilizzata dal webhook iniettore sidecar per associare i file collaterali inseriti a una determinata revisione istiod. Dopo aver aggiunto l'etichetta, tutti i pod esistenti nello spazio dei nomi devono essere riavviati per poter inserire i file collaterali.

Prima di eseguire il deployment di nuovi carichi di lavoro in un nuovo spazio dei nomi, assicurati di configurare l'inserimento automatico in modo che Anthos Service Mesh possa monitorare e proteggere il traffico.

Per abilitare l'inserimento automatico:

1. Utilizza il seguente comando per individuare l'etichetta di revisione su istiod:

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

   L'output è simile al seguente:

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

   Nell'output, sotto la colonna LABELS, prendi nota del valore dell'etichetta di revisione istiod, che segue il prefisso istio.io/rev=. In questo esempio, il valore è asm-1106-2.

2. Applica l'etichetta di revisione e rimuovi l'etichetta istio-injection, se esistente. Nel seguente comando, NAMESPACE è il nome dello spazio dei nomi in cui vuoi abilitare l'inserimento automatico e REVISION è l'etichetta di revisione che hai annotato nel passaggio precedente.

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

   Puoi ignorare il messaggio "istio-injection not found" nell'output. Ciò significa che lo spazio dei nomi non aveva in precedenza l'etichetta istio-injection, cosa che dovresti aspettarti nelle nuove installazioni di Anthos Service Mesh o nei nuovi deployment. Poiché l'inserimento automatica non riesce se uno spazio dei nomi contiene sia l'etichetta istio-injection sia l'etichetta di revisione, tutti i comandi kubectl label nella documentazione di Anthos Service Mesh comprendono la rimozione dell'etichetta istio-injection.

3. Se i carichi di lavoro erano in esecuzione sul tuo cluster prima dell'installazione di Anthos Service Mesh, riavvia i pod per attivare la reiniezione.

   La modalità di riavvio dei pod dipende dall'applicazione e dall'ambiente in cui si trova il cluster. Ad esempio, nell'ambiente di gestione temporanea potresti semplicemente eliminare tutti i pod, il che comporta il riavvio. Tuttavia, nell'ambiente di produzione potresti avere un processo che implementa un deployment blu/verde in modo da poter riavviare i pod in modo sicuro ed evitare interruzioni del traffico.

   Puoi utilizzare kubectl per eseguire un riavvio in sequenza:

   kubectl rollout restart deployment -n NAMESPACE
   

4. Verifica che i pod siano configurati in modo da puntare alla nuova versione di istiod.

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

Configurazione di un indirizzo IP esterno

L'installazione predefinita di Anthos Service Mesh presuppone che venga allocato automaticamente un indirizzo IP esterno per i servizi LoadBalancer. Questo non è vero in GKE su VMware. Per questo motivo, devi allocare manualmente un indirizzo IP per la risorsa gateway in entrata di Anthos Service Mesh.

Per configurare un indirizzo IP esterno, segui una delle sezioni seguenti, a seconda della modalità di bilanciamento del carico del cluster:

Configura la modalità di bilanciamento del carico integrata

1. Apri la configurazione del servizio istio-ingressgateway:

   kubectl edit svc -n istio-system istio-ingressgateway
   

   La configurazione per il servizio istio-ingressgateway si apre nell'editor di testo predefinito della shell.

2. Nel file, aggiungi la seguente riga sotto il blocco della specifica (spec):

   loadBalancerIP: <your static external IP address>
   

   Ad esempio:

   spec:
    loadBalancerIP: 203.0.113.1
   

3. Salva il file.

Configura la modalità di bilanciamento del carico manuale

Per esporre un servizio di tipo NodePort con un indirizzo IP virtuale (VIP) sul bilanciatore del carico, ottieni prima i valori nodePort:

1. Visualizza la configurazione del servizio istio-ingressgateway nella tua shell:

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

   Viene visualizzata ogni porta per i gateway di Anthos Service Mesh. L'output del comando è simile al seguente:

    ...
    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. Esponi queste porte tramite il bilanciatore del carico.

   Ad esempio, la porta di servizio denominata http2 ha port 80 e nodePort 31380. Supponi che gli indirizzi dei nodi per il cluster utente siano 192.168.0.10, 192.168.0.11 e 192.168.0.12 e che il VIP del bilanciatore del carico sia 203.0.113.1.

   Configura il bilanciatore del carico in modo che il traffico inviato a 203.0.113.1:80 venga inoltrato a 192.168.0.10:31380, 192.168.0.11:31380 o 192.168.0.12:31380. Puoi selezionare le porte di servizio che vuoi esporre su questo VIP.

Che cosa succede dopo?

• Esegui il deployment dell'applicazione di esempio di esempio Online Boutique