Installazione di Anthos Service Mesh on-premise con un HSM e Vault

Questa guida spiega come eseguire un'installazione pulita della versione Anthos Service Mesh 1.7.8-asm.10 su GKE su VMware e come utilizzare Thales Luna HSM 7+ e Hashicorp Vault per generare in modo sicuro la chiave di firma CA 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 attiva le funzionalità supportate sul cluster per il profilo di configurazione asm-multicloud.

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.

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

  1. Esegui l'autenticazione con Google Cloud CLI:

    gcloud auth login

  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 di server Hashicorp Vault nella tua infrastruttura per archiviare le credenziali per accedere 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, all'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 i seguenti passaggi.

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

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 directory di lavoro attuale: 
    curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.7.8-asm.10-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.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

    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.7.8-asm.10-linux-amd64.tar.gz

    Il comando crea una directory di installazione nella directory di lavoro attuale denominata istio-1.7.8-asm.10 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 install/kubernetes/operator/profiles.

    4. Mac OS

  4. 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.7.8-asm.10-osx.tar.gz
  5. Scarica il file della firma e utilizza openssl per verificare la firma: 
    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

    L'output previsto è: Verified OK

  6. 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.7.8-asm.10-osx.tar.gz

    Il comando crea una directory di installazione nella directory di lavoro attuale denominata istio-1.7.8-asm.10 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 install/kubernetes/operator/profiles.

    7. Windows

  7. 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.7.8-asm.10-win.zip
  8. Scarica il file della firma e utilizza openssl per verificare la firma: 
    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

    L'output previsto è: Verified OK

  9. 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.7.8-asm.10-win.zip

    Il comando crea una directory di installazione nella directory di lavoro attuale denominata istio-1.7.8-asm.10 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 install/kubernetes/operator/profiles.

  10. Assicurati di essere nella directory principale dell'installazione di Anthos Service Mesh. 
    cd istio-1.7.8-asm.10
  11. Per praticità, aggiungi gli strumenti nella directory /bin al tuo PERCORSO: 
    export PATH=$PWD/bin:$PATH

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}.

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

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

  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. Per inserire i pod con il proxy sidecar, devi configurare l'inserimento automatico del proxy sidecar (inserimento automatico) etichettando gli spazi dei nomi con la stessa etichetta di revisione che hai impostato su istiod quando hai installato Anthos Service Mesh.

  • Devi abilitare l'inserimento automatico in qualsiasi spazio dei nomi con carichi di lavoro in esecuzione nel cluster prima dell'installazione di Anthos Service Mesh.

  • Prima di eseguire il deployment di nuovi carichi di lavoro, 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-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

    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-178-10.

  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?