Anthos Service Mesh 1.10 ist abgelaufen und wird nicht mehr unterstützt. Siehe Upgraden von früheren Versionen.

Lesen Sie die aktuelle Dokumentation oder wählen Sie eine andere verfügbare Version aus:

Verfügbare Versionen

1.20 (neueste Version)
1.19
1.18
1.17
1.16
1.15
1.14
1.13
1.12
1.11
1.10
1.9
1.8
1.7
1.6
1.5
1.4

Anthos Service Mesh lokal mit einem HSM und Vault installieren

In dieser Anleitung wird erläutert, wie Sie Anthos Service Mesh auf vorhandener GKE on VMware installieren und Thales Luna HSM 7+ und Hashicorp Vault verwenden, um den CA-Signaturschlüssel von Istiod sicher zu generieren und den CA-Signaturschlüssel zu schützen.

Wenn Sie eine frühere Version von Anthos Service Mesh installiert haben, lesen Sie Anthos Service Mesh GKE auf VMware aktualisieren. Mit dieser Installation werden die unterstützten Funktionen auf Ihrem Cluster aktiviert.

Hinweise

Lesen Sie die folgenden Voraussetzungen, bevor Sie mit der Einrichtung beginnen.

Voraussetzungen

Sie benötigen ein Anthos-Abo. Alternativ ist eine „Pay as you go“-Abrechnungsoption nur für GKE Enterprise in Google Cloud verfügbar. Weitere Informationen finden Sie in der GKE Enterprise-Preisübersicht.
Sie müssen sich an das Supportteam wenden, damit Ihnen Zugriff auf die Images gewährt wird. Vom Supportteam erhalten Sie auch zusätzliche Hilfe.
Prüfen Sie, ob der Cluster, in dem Anthos Service Mesh installiert werden soll, über mindestens vier vCPUs, 15 GB Arbeitsspeicher und vier Knoten verfügt.
Verwenden Sie für die Benennung Ihrer Dienstports die folgende Syntax: name: protocol[-suffix]. Die eckigen Klammern geben dabei ein optionales Suffix an, das mit einem Bindestrich beginnen muss. Weitere Informationen finden Sie unter Dienstports benennen.
Prüfen Sie, ob Ihre Clusterversion unter Unterstützte Umgebungen aufgeführt ist. Mit dem gkectl-Befehlszeilentool können Sie die Clusterversion prüfen. Wenn gkectl nicht installiert ist, lesen Sie die Informationen unter GKE On-Prem-Downloads.
```
gkectl version
```
In Ihrer Infrastruktur sollte Thales Luna HSM 7+ enthalten sein. Für das HSM sollte ein Netzwerkdienst eingerichtet und über den Anthos Service Mesh-Cluster erreichbar sein.
In Ihrer Infrastruktur sollten sich Hashicorp Vault-Server zum Speichern der Anmeldedaten für den Zugriff auf das HSM befinden. Die Vault-Server sollten für den Anthos Service Mesh-Cluster über das Netzwerk erreichbar sein.

Umgebung einrichten

Installieren Sie die folgenden Tools auf dem Computer, über den Sie die Installation von Anthos Service Mesh steuern.

curl-Befehlszeilentool
Google Cloud CLI

Führen Sie nach der Installation der erforderlichen Tools die folgenden Schritte aus:

Authentifizieren Sie sich über die gcloud CLI:
```
gcloud auth login --project PROJECT_ID
```
Aktualisieren Sie die Komponenten:
```
gcloud components update
```
Installieren Sie kubectl:
```
gcloud components install kubectl
```
Installieren Sie zum Bereitstellen und Testen der Installation mit der Online-Boutique-Beispielanwendung kpt:
```
gcloud components install kpt
```
Wechseln Sie den Kontext zu Ihrem Nutzercluster (falls nötig):
```
kubectl config use-context CLUSTER_NAME
```
Gewähren Sie dem Nutzerkonto Administratorberechtigungen (Ihre E-Mail-Adresse für die Anmeldung in Google Cloud). Sie benötigen diese Berechtigungen, um die erforderlichen Regeln für die rollenbasierte Zugriffssteuerung (Role Based Access Control, RBAC) für Anthos Service Mesh zu erstellen:
```
kubectl create clusterrolebinding cluster-admin-binding \
  --clusterrole=cluster-admin \
  --user=USER_ACCOUNT
```

Abhängigkeiten bereitstellen

Stellen Sie in Ihrer Infrastruktur Thales Luna HSM 7+ bereit, um die Signierschlüssel der Zertifizierungsstelle von Istiod sicher zu verwalten. Achten Sie darauf, dass das HSM einen Netzwerkdienst und eine Verbindung zum Anthos Service Mesh-Cluster hat.
Stellen Sie in Ihrer Infrastruktur Hashicorp Vault-Server zum Speichern der Anmeldedaten für den Zugriff auf das HSM bereit. Achten Sie darauf, dass die Vault-Server eine Netzwerkverbindung zum Anthos Service Mesh-Cluster haben.
Sie müssen eine Workstation mit Zugriff auf den Vault-Server, HSM und den Kubernetes-Cluster haben, auf dem Sie Anthos Service Mesh installieren möchten.

Hardwaresicherheitsmodul (HSM) einrichten

In diesem Abschnitt werden die Schritte zum Einrichten des Hardwaresicherheitsmoduls (HSM) und zum Generieren von Verschlüsselungsschlüsseln beschrieben.

HSM-Anmeldedaten und Slot bereitstellen

Folgen Sie der HSM-Installationsanleitung, um die folgenden Schritte auszuführen.

Richten Sie das HSM als Netzwerk-HSM ein.
Stellen Sie PEM-Dateien für mTLS-Verbindungen zum HSM bereit, einschließlich Client-Schlüsseldatei, Clientzertifikat und Serverzertifikatsdatei.
Stellen Sie einen HSM-Slot für Anthos Service Mesh bereit und notieren Sie sich das Slotlabel und die PIN.

HSM-Schlüsselverschlüsselungsschlüssel (KEK) generieren

Laden Sie auf dem Computer mit Zugriff auf HSM das HSM-Tool herunter (nur für Linux amd-64 verfügbar).
```
gsutil cp gs://artifacts.thalescpl-io-k8s-kms-plugin.appspot.com/binary/k8s-kms-plugin .
```

Legen Sie Umgebungsvariablen fest, bevor Sie das HSM-Tool als lokalen Server ausführen, der eine Verbindung zum HSM herstellt und für die Bereitstellung auf dem lokalen Unix Domain Socket (UDS) sorgt.

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 &

Die Ausgabe sollte in etwa so aussehen:

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"

Wenn Sie keinen Schlüsselverschlüsselungsschlüssel (KEK) auf dem HSM haben, führen Sie die folgenden Schritte aus, um einen zu generieren. Verwenden Sie k8s-kms-plugin als Client für die Kommunikation mit dem Server des HSM-Tools. Wenn Sie explizit eine KEK-ID angeben möchten, können Sie im Befehl das Flag --kek-id übergeben. Andernfalls wird automatisch eine zufällige KEK-ID generiert.
```
./k8s-kms-plugin generate-kek --kek-id KEK ID
```
Notieren Sie sich die KEK-ID. Sie benötigen sie für die folgenden Schritte.
HSM verwendet das importierte Root-Zertifikat, um das signierte CA-Zertifikat von Istiod zu überprüfen. Mit diesem Schritt können Sie das Root-Zertifikat in das HSM importieren. Verwenden Sie k8s-kms-plugin als Client, um mit dem Server des HSM-Tools zu kommunizieren. Importieren Sie mit dem folgenden Befehl das Root-Zertifikat.
```
./k8s-kms-plugin import-ca -f root cert PEM file
```

Kubernetes für die Vault-Authentifizierung einrichten

Erstellen Sie im Kubernetes-Cluster ein dediziertes Dienstkonto und eine RBAC-Richtlinie für Vault, um die API TokenReview aufzurufen. Erstellen Sie zu diesem Zweck einen dedizierten Namespace.
Erstellen Sie das Standarddienstkonto im Namespace vault, legen Sie die Berechtigungen fest und extrahieren Sie das zugehörige JSON-Webtoken (JWT) für den Vault-Server, um die Kubernetes TokenReview API aufzurufen. Hinweis: Sie können ein beliebiges Kubernetes-Dienstkonto und beliebige Namespaces verwenden, wenn diese über ausreichende Berechtigungen verfügen.
Konfigurieren Sie das Clustersuffix für den Cluster, den Sie einrichten möchten. Verwenden Sie für die Konfiguration ein dediziertes Verzeichnis.
```
export CLUSTER_SUFFIX="c1"
mkdir ${CLUSTER_SUFFIX}
cd ${CLUSTER_SUFFIX}
```
Wechseln Sie zu dem Cluster, den Sie verwalten möchten, und erstellen Sie den Namespace vault. kubectl erstellt das Standarddienstkonto automatisch.
```
kubectl create ns vault
```

Binden Sie das Dienstkonto default.vault zum Erteilen von Berechtigungen an die Rolle 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

Erstellen Sie ein Secret für die Token-Anmeldedaten.

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

Rufen Sie das JWT für das Dienstkonto default.vault ab.

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

Rufen Sie die Adresse und das Zertifikat des Kubernetes API-Servers ab. Konfigurieren Sie dann den Vault-Server so, dass er den Kubernetes API-Server aufruft.

Rufen Sie die öffentlichen IP:Port-Werte von Kubernetes ab.

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

Rufen Sie das Zertifikat zum Authentifizieren des Kubernetes API-Servers ab.

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"

Konvertieren Sie die Zertifikatsdatei in das PEM-Dateiformat und validieren Sie sie.

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

Überprüfen Sie, ob das Zertifikat gültig ist.

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

Wechseln Sie zurück zum vorherigen Verzeichnis.
```
cd ..
```

Verwenden Sie jetzt die drei Dateien im Verzeichnis des Clusters, um im nächsten Schritt Vault zu konfigurieren.

Vault zum Speichern von HSM-Anmeldedaten einrichten

Wenn der Vault-Server TLS-Traffic mit einem gültigen Zertifikat bereitstellt, konfigurieren Sie die Vault-PKI und die Kubernetes-Authentifizierung. Das folgende Beispiel zeigt die Einrichtung einer einzelnen Stammzertifizierungsstelle und zwischengeschalteter Zertifizierungsstellen pro Cluster.

Melden Sie sich als Root bei Vault an.
```
vault login
```

Speichern Sie das Secret für das 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}

Erstellen Sie eine Richtlinie mit Berechtigungen für den PKI-Pfad.

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

Fügen Sie die Kubernetes-Authentifizierung für den Cluster hinzu.
```
vault auth enable --path="${HSM_SECRET_PATH}"  kubernetes
```

Legen Sie das Kubernetes-JWT, die Kubernetes-Adresse und das CA-Zertifikat von Kubernetes auf den Vault-Authentifizierungspfad fest.

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

Erlauben Sie istiod-service-account.istio-system die Authentifizierung als Rolle demo und verwenden Sie die erstellte Richtlinie.

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

Kehren Sie zum übergeordneten Ordner zurück.
```
cd ..
```

Installationsdatei herunterladen

Linux

Laden Sie die Anthos Service Mesh-Installationsdatei in Ihr aktuelles Arbeitsverzeichnis herunter:
```
curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.10.6-asm.2-linux-amd64.tar.gz
```

Laden Sie die Signaturdatei herunter und bestätigen Sie die Signatur mit openssl:

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

Folgende Ausgabe wird erwartet: Verified OK

Entpacken Sie die Inhalte der Datei in einem Verzeichnis Ihres Dateisystems. So extrahieren Sie beispielsweise den Inhalt in das aktuelle Arbeitsverzeichnis:
```
 tar xzf istio-1.10.6-asm.2-linux-amd64.tar.gz
```
Mit diesem Befehl wird in Ihrem aktuellen Arbeitsverzeichnis istio-1.10.6-asm.2 ein Installationsverzeichnis erstellt, das Folgendes enthält:
- Beispielanwendungen im Verzeichnis samples.
- Das istioctl-Befehlszeilentool, mit dem Sie Anthos Service Mesh installieren, befindet sich im Verzeichnis bin.
- Die Anthos Service Mesh-Konfigurationsprofile befinden sich im Verzeichnis manifests/profiles.
Prüfen Sie, ob Sie sich im Stammverzeichnis der Anthos Service Mesh-Installation befinden.
```
cd istio-1.10.6-asm.2
```

macOS

Laden Sie die Anthos Service Mesh-Installationsdatei in Ihr aktuelles Arbeitsverzeichnis herunter:
```
curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.10.6-asm.2-osx.tar.gz
```

Laden Sie die Signaturdatei herunter und bestätigen Sie die Signatur mit openssl:

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

Folgende Ausgabe wird erwartet: Verified OK

Entpacken Sie die Inhalte der Datei in einem Verzeichnis Ihres Dateisystems. So extrahieren Sie beispielsweise den Inhalt in das aktuelle Arbeitsverzeichnis:
```
tar xzf istio-1.10.6-asm.2-osx.tar.gz
```
Mit diesem Befehl wird in Ihrem aktuellen Arbeitsverzeichnis istio-1.10.6-asm.2 ein Installationsverzeichnis erstellt, das Folgendes enthält:
- Beispielanwendungen im Verzeichnis samples.
- Das istioctl-Befehlszeilentool, mit dem Sie Anthos Service Mesh installieren, befindet sich im Verzeichnis bin.
- Die Anthos Service Mesh-Konfigurationsprofile befinden sich im Verzeichnis manifests/profiles.
Prüfen Sie, ob Sie sich im Stammverzeichnis der Anthos Service Mesh-Installation befinden.
```
cd istio-1.10.6-asm.2
```

Windows

Laden Sie die Anthos Service Mesh-Installationsdatei in Ihr aktuelles Arbeitsverzeichnis herunter:
```
curl -LO https://storage.googleapis.com/gke-release/asm/istio-1.10.6-asm.2-win.zip
```

Laden Sie die Signaturdatei herunter und bestätigen Sie die Signatur mit openssl:

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

Folgende Ausgabe wird erwartet: Verified OK

Entpacken Sie die Inhalte der Datei in einem Verzeichnis Ihres Dateisystems. So extrahieren Sie beispielsweise den Inhalt in das aktuelle Arbeitsverzeichnis:
```
tar xzf istio-1.10.6-asm.2-win.zip
```
Mit diesem Befehl wird in Ihrem aktuellen Arbeitsverzeichnis istio-1.10.6-asm.2 ein Installationsverzeichnis erstellt, das Folgendes enthält:
- Beispielanwendungen im Verzeichnis samples.
- Das istioctl-Befehlszeilentool, mit dem Sie Anthos Service Mesh installieren, befindet sich im Verzeichnis bin.
- Die Anthos Service Mesh-Konfigurationsprofile befinden sich im Verzeichnis manifests/profiles.
Prüfen Sie, ob Sie sich im Stammverzeichnis der Anthos Service Mesh-Installation befinden.
```
cd istio-1.10.6-asm.2
```

Ressource in der Steuerungsebene einrichten

Legen Sie die Umgebungsvariablen fest.

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

Kopieren Sie die Datei mit dem Zertifikat zur Authentifizierung von Vault in eine Datei mit dem Namen cert. Zum Beispiel das TLS-Zertifikat des Vault-Servers: ${VAULT_CACERT}.

Hinweis: Der Vault-Client verwendet dieses Zertifikat zur Authentifizierung des Vault-Servers. Dieses Zertifikat unterscheidet sich von dem Zertifikat, das von Vault zur Authentifizierung des Kubernetes API-Servers verwendet wird.
```
cp ${VAULT_CACERT} ./cert
```

Erstellen Sie eine ConfigMap aus der Datei im 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

Validierungs-Webhook konfigurieren

Wenn Sie Anthos Service Mesh installieren, legen Sie ein Überarbeitungslabel auf istiod fest. Sie müssen für den Validierungs-Webhook dieselbe Überarbeitung festlegen.

Kopieren Sie die folgende YAML-Datei in eine Datei mit dem Namen 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

Anthos Service Mesh installieren

Richten Sie die Umgebungsvariablen ein, um ASM für die Interaktion mit Vault und dem HSM zu konfigurieren. Der folgende Befehl verkürzt die Wartezeit auf zehn Sekunden, da Istiod aufgrund des ausstehenden Importvorgangs durch den Operator nicht vollständig bereit ist.

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

Führen Sie den folgenden Befehl aus, um Anthos Service Mesh mit dem Profil asm-multicloud zu installieren. Wenn Sie ein unterstütztes optionales Feature aktivieren möchten, fügen Sie in der folgenden Befehlszeile -f und den YAML-Dateinamen hinzu. Weitere Informationen finden Sie unter Optionale Features aktivieren.

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"

Konfigurieren Sie den Validierungs-Webhook so, dass er den Dienst istiod mit dem Überarbeitungslabel finden kann:
```
kubectl apply -f istiod-service.yaml
```
Mit diesem Befehl wird ein Diensteintrag erstellt. Dies ermöglicht es dem Validierungs-Webhook, automatisch Konfigurationen automatisch zu prüfen, bevor sie angewendet werden.
Prüfen Sie, ob Istiod ordnungsgemäß initialisiert wurde und sich im Wartestatus befindet.
```
kubectl get pod -l app=istiod -n istio-system
```
Die Ausgabe sieht in etwa so aus:
```
NAME                      READY   STATUS    RESTARTS   AGE
istiod-66ff56d76c-f9p5l   2/3     Running   2          1m27s
```
Istiod ist nicht vollständig bereit, da der discovery-Container blockiert ist und auf das Zertifikat wartet.

Prüfen Sie anhand des Logs der Istiod-Container, ob sie sich im richtigen Zustand befinden.

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

Die Ausgabe sieht in etwa so aus:

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

Die letzte Ausgabezeile sieht in etwa so aus:

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

Signierzertifikat für Istiod

Laden Sie die verschlüsselte CSR aus dem Kubernetes-Secret herunter.

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

Entschlüsseln Sie die 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

Der Sicherheitsadministrator sollte die csr.pem-Datei verwenden und mithilfe der Stammzertifizierungsstelle signieren.
Legen Sie die Zertifikatskette im Stammverzeichnis der Datei mit dem Namen cert-chain.pem ab und führen Sie dann den folgenden Befehl aus.
```
kubectl create secret generic istio-ca-cert --from-file=cert-chain.pem -n istio-system
```

Überprüfen Sie, ob Istiod die neue Zertifikatskette erfolgreich geladen hat. Prüfen Sie dazu das Istiod-Log.

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

Die Ausgabe sollte in etwa so aussehen:

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

Zwischenzertifikate: -----ANFANG DES ZERTIFIKATS----- -----ENDE DES ZERTIFIKATS-----

Stammzertifikat: -----ANFANG DES ZERTIFIKATS----- -----ENDE DES ZERTIFIKATS-----

Installation überprüfen

Führen Sie die folgenden Schritte aus, um zu prüfen, ob die Anthos Service Mesh-Installation ordnungsgemäß funktioniert.

Komponenten der Steuerungsebene prüfen

Prüfen Sie, ob die Pods der Steuerungsebene in istio-system ausgeführt werden:

kubectl get pod -n istio-system

Die erwartete Ausgabe sieht in etwa so aus:

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

Lösen Sie einen TLS-Aufruf an einen Dienst aus der Sidecar-Datei aus und prüfen Sie das vom Dienst verwendete Zertifikat, zum Beispiel mithilfe von Bookinfo.
```
kubectl exec POD -c istio-proxy -- openssl s_client -alpn istio -showcerts -connect details:9080
```
Prüfen Sie die Zertifikate in der Ausgabe. Dort sollte die serverseitige Zertifikatskette angezeigt werden.

Sidecar-Proxys einfügen

Anthos Service Mesh verwendet Sidecar-Proxys, um die Sicherheit, Zuverlässigkeit und Beobachtbarkeit von Netzwerken zu verbessern. Mit Anthos Service Mesh werden diese Funktionen vom primären Container der Anwendung abstrahiert und in einem gemeinsamen Out-of-Process-Proxy implementiert, der als separater Container im selben Pod bereitgestellt wird.

Die Installation ist erst abgeschlossen, wenn Sie die automatische Sidecar-Proxy-Einfügung (automatische Injektion) aktivieren und die Pods für alle Arbeitslasten neu starten, die auf dem Cluster ausgeführt wurden, bevor Sie Anthos Service Mesh installiert haben.

Wenn Sie die automatische Injektion aktivieren möchten, versehen Sie Ihre Namespaces mit dem Überarbeitungslabel, das bei der Installation von Anthos Service Mesh auf istiod festgelegt wurde. Das Überarbeitungslabel wird vom Sidecar-Injektor-Webhook verwendet, um eingefügte Sidecars mit einer bestimmten istiod-Überarbeitung zu verknüpfen. Nachdem Sie das Label hinzugefügt haben, müssen alle im Namespace vorhandenen Pods neu gestartet werden, damit Sidecars eingefügt werden können.

Bevor Sie neue Arbeitslasten in einem neuen Namespace bereitstellen, müssen Sie die automatische Injektion konfigurieren, damit Anthos Service Mesh den Traffic überwachen und sichern kann.

So aktivieren Sie die automatische Einfügung:

Verwenden Sie den folgenden Befehl, um das Überarbeitungslabel für istiod zu finden:

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

Die Ausgabe sieht dann ungefähr so aus:

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

Notieren Sie sich den Wert des Überarbeitungslabels istiod aus der Ausgabe in der Spalte LABELS, das auf das Präfix istio.io/rev= folgt. In diesem Beispiel ist der Wert asm-1106-2.

Wenden Sie das Überarbeitungslabel an und entfernen Sie das Label istio-injection, falls vorhanden. Im folgenden Befehl ist NAMESPACE der Name des Namespace, in dem Sie die automatische Einfügung aktivieren möchten. REVISION ist das Überarbeitungslabel, das Sie im vorherigen Schritt notiert haben.
```
kubectl label namespace NAMESPACE istio-injection- istio.io/rev=REVISION --overwrite
```
Sie können die Nachricht "istio-injection not found" in der Ausgabe ignorieren. Das bedeutet, dass der Namespace bisher nicht das Label istio-injection hatte, was bei Neuinstallationen von Anthos Service Mesh oder neuen Bereitstellungen zu erwarten wäre. Da die automatische Einfügung fehlschlägt, wenn ein Namespace sowohl das Label istio-injectionals auch das Überarbeitungslabel enthält, umfassen alle kubectl label-Befehle in der Anthos Service Mesh-Dokumentation das Entfernen des Labels istio-injection.
Wenn vor der Installation von Anthos Service Mesh in Ihrem Cluster Arbeitslasten ausgeführt wurden, starten Sie die Pods neu, um eine erneute Injektion auszulösen.

Wie Sie Pods neu starten, hängt von der Anwendung und der Umgebung ab, in der sich der Cluster befindet. Beispielsweise können Sie in Ihrer Staging-Umgebung einfach alle Pods löschen, wodurch sie neu gestartet werden. Aber in Ihrer Produktionsumgebung haben Sie vielleicht einen Prozess, der ein Blau/Grün-Deployment implementiert, sodass Pods sicher neu gestartet werden können, um Traffic-Unterbrechungen zu vermeiden.

Sie können kubectl verwenden, um einen rollierenden Neustart durchzuführen:
```
kubectl rollout restart deployment -n NAMESPACE
```
Überprüfen Sie, ob Ihre Pods so konfiguriert sind, dass sie auf die neue Version von istiod verweisen.
```
kubectl get pods -n NAMESPACE -l istio.io/rev=REVISION
```

Externe IP-Adresse konfigurieren

Die Standardinstallation von Anthos Service Mesh geht davon aus, dass LoadBalancer-Diensten automatisch eine externe IP-Adresse zugewiesen wird. Dies gilt nicht für GKE on VMware. Aus diesem Grund müssen Sie der IP-Adresse des Anthos Service Mesh-Ingress-Gateways manuell eine IP-Adresse zuweisen.

Folgen Sie zum Konfigurieren einer externen IP-Adresse einem der folgenden Abschnitte je nach Load-Balancing-Modus des Clusters:

Integrierten Load-Balancing-Modus konfigurieren

Öffnen Sie die Konfiguration des istio-ingressgateway-Dienstes:
```
kubectl edit svc -n istio-system istio-ingressgateway
```
Die Konfiguration für den Dienst istio-ingressgateway wird im Standardtexteditor der Shell aufgerufen.
Fügen Sie der Datei die folgende Zeile unter dem Spezifikationsblock (spec) hinzu:
```
loadBalancerIP: <your static external IP address>
```
Beispiel:
```
spec:
 loadBalancerIP: 203.0.113.1
```
Speichern Sie die Datei.

Manuellen Load-Balancing-Modus konfigurieren

Wenn Sie einen Dienst vom Typ NodePort mit einer virtuellen IP-Adresse (VIP) auf Ihrem Load-Balancer verfügbar machen möchten, rufen Sie zuerst die nodePort-Werte ab:

Rufen Sie die Konfiguration des Dienstes istio-ingressgateway in der Shell auf:

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

Jeder Port für die Gateways von Anthos Service Mesh wird angezeigt. Die entsprechende Befehlsausgabe sieht etwa so aus:

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

Machen Sie diese Ports über Ihren Load-Balancer verfügbar.

Der Dienstport http2 hat beispielsweise port 80 und nodePort 31380. Angenommen, die Knotenadressen für Ihren Nutzercluster lauten 192.168.0.10, 192.168.0.11 und 192.168.0.12 und die VIP Ihres Load-Balancers ist 203.0.113.1.

Konfigurieren Sie dann Ihren Load-Balancer so, dass der an 203.0.113.1:80 gesendete Traffic an 192.168.0.10:31380, 192.168.0.11:31380 oder 192.168.0.12:31380 weitergeleitet wird. Sie können die Dienstports auswählen, die Sie für diese VIP freigeben möchten.

Nächste Schritte

Beispielanwendung Online Boutique auf Anthos Service Mesh bereitstellen