Anthos Service Mesh 1.10 telah mencapai akhir siklus proses dan tidak lagi didukung. Lihat Mengupgrade dari versi sebelumnya.

Lihat dokumentasi terbaru atau pilih versi lain yang tersedia:

Versi yang tersedia

1.20 (terbaru)
1.19
1.18
1.17
1.16
1.15
1.14
1.13
1.12
1.12

219}

Menginstal Anthos Service Mesh secara lokal dengan HSM dan Vault

Panduan ini menjelaskan cara menginstal Anthos Service Mesh di GKE yang ada di VMware serta menggunakan Thales Luna HSM 7+ dan Hashicorp Vault untuk membuat kunci penandatanganan CA Istiod dengan aman dan melindungi kunci penandatanganan CA.

Jika Anda sudah menginstal Anthos Service Mesh versi sebelumnya, lihat Mengupgrade Anthos Service Mesh GKE di VMware. Penginstalan ini akan mengaktifkan fitur yang didukung di cluster Anda.

Sebelum memulai

Tinjau persyaratan berikut sebelum Anda memulai penyiapan.

Persyaratan

Anda harus memiliki langganan Anthos. Atau, opsi penagihan bayar sesuai penggunaan hanya tersedia untuk GKE Enterprise di Google Cloud. Untuk informasi selengkapnya, lihat panduan Harga GKE Enterprise.
Anda harus menghubungi tim dukungan untuk memberi Anda izin agar dapat mengakses gambar. Tim dukungan juga akan memberikan bantuan tambahan.
Pastikan cluster tempat Anda menginstal Anthos Service Mesh memiliki minimal 4 vCPU, memori 15 GB, dan 4 node.
Anda harus memberi nama port layanan menggunakan sintaksis berikut: name: protocol[-suffix] dengan tanda kurung siku menunjukkan akhiran opsional yang harus diawali dengan tanda hubung. Untuk mengetahui informasi selengkapnya, lihat Penamaan port layanan.
Pastikan versi cluster Anda tercantum di Lingkungan yang didukung. Untuk memeriksa versi cluster, Anda dapat menggunakan alat command line gkectl. Jika Anda belum menginstal gkectl, lihat download GKE lokal.
```
gkectl version
```
Anda harus memiliki Thales Luna HSM 7+ di infrastruktur Anda. HSM harus menyiapkan layanan jaringan dan dapat dijangkau dari cluster Anthos Service Mesh.
Anda harus memiliki server Hashicorp Vault di infrastruktur untuk menyimpan kredensial untuk mengakses HSM. Server Vault harus dapat dijangkau dari cluster Anthos Service Mesh melalui jaringan.

Menyiapkan lingkungan Anda

Instal alat berikut di komputer tempat Anda mengontrol proses penginstalan Anthos Service Mesh.

Alat command line curl.
Google Cloud CLI.

Setelah menginstal alat prasyarat, lakukan langkah-langkah berikut:

Lakukan autentikasi dengan gcloud CLI:
```
gcloud auth login --project PROJECT_ID
```
Update komponen:
```
gcloud components update
```
Instal kubectl:
```
gcloud components install kubectl
```
Untuk men-deploy dan menguji penginstalan dengan aplikasi contoh Online Boutique, instal kpt:
```
gcloud components install kpt
```
Alihkan konteks ke cluster pengguna Anda (jika perlu):
```
kubectl config use-context CLUSTER_NAME
```
Berikan izin admin cluster ke akun pengguna Anda (alamat email login Google Cloud Anda). Anda memerlukan izin berikut agar dapat membuat aturan role-based access control (RBAC) yang diperlukan untuk Anthos Service Mesh:
```
kubectl create clusterrolebinding cluster-admin-binding \
  --clusterrole=cluster-admin \
  --user=USER_ACCOUNT
```

Men-deploy dependensi

Deploy Thales Luna HSM 7+ di infrastruktur Anda untuk mengelola kunci penandatanganan Istiod CA dengan aman. Pastikan HSM memiliki layanan jaringan dan konektivitas dengan cluster Anthos Service Mesh.
Deploy server Hashicorp Vault di infrastruktur Anda untuk menyimpan kredensial untuk mengakses HSM. Pastikan server Vault memiliki konektivitas jaringan dengan cluster Anthos Service Mesh.
Memiliki workstation dengan akses ke server Vault, HSM, dan cluster Kubernetes tempat Anda menginstal Anthos Service Mesh.

Menyiapkan modul keamanan hardware (HSM)

Bagian ini mencantumkan langkah-langkah untuk menyiapkan modul keamanan hardware (HSM) dan membuat kunci enkripsi.

Menyediakan kredensial dan slot HSM

Ikuti panduan penginstalan HSM untuk melakukan langkah-langkah berikut.

Siapkan HSM sebagai HSM jaringan.
Menyediakan file PEM untuk koneksi mTLS dengan HSM, termasuk file kunci klien, file sertifikat klien, dan file sertifikat server.
Sediakan slot HSM untuk Anthos Service Mesh dan catat label slot dan PIN.

Membuat Kunci Enkripsi Kunci HSM (KEK)

Di komputer yang memiliki akses ke HSM, download alat HSM (hanya tersedia untuk Linux amd-64).
```
gsutil cp gs://artifacts.thalescpl-io-k8s-kms-plugin.appspot.com/binary/k8s-kms-plugin .
```

Tetapkan variabel lingkungan sebelum Anda menjalankan alat HSM sebagai server lokal, yang terhubung ke HSM dan berfungsi pada Unix Domain Socket (UDS) lokal.

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 &

Nantikan output yang mirip dengan berikut ini:

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"

Jika Anda tidak memiliki Kunci Enkripsi Kunci (KEK) pada HSM, ikuti langkah-langkah berikut untuk membuatnya. Gunakan k8s-kms-plugin sebagai klien untuk berkomunikasi dengan server alat HSM. Jika ingin menentukan ID KEK secara eksplisit, Anda dapat meneruskan flag --kek-id dalam perintah ini. Jika tidak, ID KEK acak akan dibuat secara otomatis.
```
./k8s-kms-plugin generate-kek --kek-id KEK ID
```
Catat ID KEK. Anda akan menggunakannya di langkah-langkah berikut.
HSM menggunakan root certificate yang diimpor untuk memverifikasi sertifikat CA Istiod yang ditandatangani. Anda dapat mengikuti langkah ini untuk mengimpor root certificate ke HSM. Gunakan k8s-kms-plugin sebagai klien untuk berbicara dengan server alat HSM. Impor root certificate menggunakan perintah berikut.
```
./k8s-kms-plugin import-ca -f root cert PEM file
```

Menyiapkan Kubernetes untuk autentikasi Vault

Di cluster Kubernetes, buat akun layanan dan kebijakan RBAC khusus agar Vault dapat memanggil TokenReview API. Buat namespace khusus untuk tujuan ini.
Buat akun layanan default di namespace vault, setel izin, dan ekstrak Token Web JSON (JWT) terkait untuk server Vault guna memanggil Kubernetes TokenReview API. Catatan: Anda dapat menggunakan namespace dan akun layanan Kubernetes apa pun jika memiliki izin yang memadai.
Konfigurasikan akhiran cluster Anda untuk cluster yang ingin disiapkan. Gunakan direktori khusus untuk konfigurasi.
```
export CLUSTER_SUFFIX="c1"
mkdir ${CLUSTER_SUFFIX}
cd ${CLUSTER_SUFFIX}
```
Beralihlah ke cluster yang ingin Anda kelola dan buat namespace vault. kubectl membuat akun layanan default secara otomatis.
```
kubectl create ns vault
```

Untuk memberikan izin, ikat akun layanan default.vault ke peran 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

Buat secret untuk menyimpan kredensial 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

Dapatkan JWT untuk akun layanan 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

Ambil alamat dan sertifikat CA server Kubernetes API. Kemudian, konfigurasikan server Vault untuk memanggil server Kubernetes API.

Mendapatkan nilai IP:Port publik 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

Mendapatkan sertifikat untuk mengautentikasi server Kubernetes API.

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"

Konversikan file sertifikat ke dalam format file PEM dan validasikan file tersebut.

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

Verifikasi bahwa sertifikat valid.

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

Kembali ke direktori sebelumnya.
```
cd ..
```

Sekarang, gunakan tiga file di direktori cluster untuk mengonfigurasi Vault pada langkah berikutnya.

Menyiapkan Vault untuk menyimpan kredensial HSM

Saat server Vault menyalurkan traffic TLS dengan sertifikat yang valid, konfigurasikan IKP Vault dan konfigurasikan autentikasi Kubernetes. Berikut adalah contoh untuk menyiapkan satu CA root dan CA perantara per cluster.

Simpan rahasia untuk 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}

Buat kebijakan dengan izin ke jalur IKP.

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

Menambahkan autentikasi Kubernetes untuk cluster.

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

Tetapkan JWT Kubernetes, alamat Kubernetes, dan sertifikat CA Kubernetes ke jalur autentikasi 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

Izinkan istiod-service-account.istio-system untuk mengautentikasi sebagai peran demo, dan gunakan kebijakan yang dibuat.

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

Kembali ke folder induk.
```
cd ..
```

Mendownload file penginstalan

Linux

Download file penginstalan Anthos Service Mesh ke direktori kerja saat ini:

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

Download file tanda tangan dan gunakan openssl untuk memverifikasi tanda tangan:

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

Output yang diharapkan adalah: Verified OK.

Ekstrak konten file ke lokasi mana saja di sistem file Anda. Misalnya, untuk mengekstrak konten ke direktori kerja saat ini:
```
 tar xzf istio-1.10.6-asm.2-linux-amd64.tar.gz
```
Perintah tersebut membuat direktori penginstalan di direktori kerja saat ini bernama istio-1.10.6-asm.2 yang berisi:
- Contoh aplikasi di direktori samples.
- Alat command line istioctl yang Anda gunakan untuk menginstal Anthos Service Mesh ada di direktori bin.
- Profil konfigurasi Anthos Service Mesh berada di direktori manifests/profiles.
Pastikan Anda berada di direktori utama penginstalan Anthos Service Mesh.
```
cd istio-1.10.6-asm.2
```

Mac OS

Download file penginstalan Anthos Service Mesh ke direktori kerja Anda saat ini:

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

Download file tanda tangan dan gunakan openssl untuk memverifikasi tanda tangan:

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

Output yang diharapkan adalah: Verified OK.

Ekstrak konten file ke lokasi mana saja di sistem file Anda. Misalnya, untuk mengekstrak konten ke direktori kerja saat ini:
```
tar xzf istio-1.10.6-asm.2-osx.tar.gz
```
Perintah tersebut membuat direktori penginstalan di direktori kerja saat ini bernama istio-1.10.6-asm.2 yang berisi:
- Contoh aplikasi di direktori samples.
- Alat command line istioctl yang Anda gunakan untuk menginstal Anthos Service Mesh ada di direktori bin.
- Profil konfigurasi Anthos Service Mesh berada di direktori manifests/profiles.
Pastikan Anda berada di direktori utama penginstalan Anthos Service Mesh.
```
cd istio-1.10.6-asm.2
```

Windows

Download file penginstalan Anthos Service Mesh ke direktori kerja Anda saat ini:

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

Download file tanda tangan dan gunakan openssl untuk memverifikasi tanda tangan:

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

Output yang diharapkan adalah: Verified OK.

Ekstrak konten file ke lokasi mana saja di sistem file Anda. Misalnya, untuk mengekstrak konten ke direktori kerja saat ini:
```
tar xzf istio-1.10.6-asm.2-win.zip
```
Perintah tersebut membuat direktori penginstalan di direktori kerja saat ini bernama istio-1.10.6-asm.2 yang berisi:
- Contoh aplikasi di direktori samples.
- Alat command line istioctl yang Anda gunakan untuk menginstal Anthos Service Mesh ada di direktori bin.
- Profil konfigurasi Anthos Service Mesh berada di direktori manifests/profiles.
Pastikan Anda berada di direktori utama penginstalan Anthos Service Mesh.
```
cd istio-1.10.6-asm.2
```

Menyiapkan resource di bidang kontrol

Menetapkan variabel lingkungan.

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

Salin file yang berisi sertifikat untuk mengautentikasi Vault ke file bernama cert. Misalnya, sertifikat TLS server Vault, ${VAULT_CACERT}.

Catatan: Klien vault menggunakan sertifikat ini untuk mengautentikasi server Vault. Sertifikat ini berbeda dengan sertifikat yang digunakan oleh Vault untuk mengautentikasi server Kubernetes API.
```
cp ${VAULT_CACERT} ./cert
```

Buat ConfigMap dari file dalam istio-system namespace.

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

Mengonfigurasi webhook validasi

Saat menginstal Anthos Service Mesh, Anda menetapkan label revisi pada istiod. Anda harus menetapkan revisi yang sama pada webhook validasi.

Salin YAML berikut ke file bernama 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

Menginstal Anthos Service Mesh

Siapkan variabel lingkungan untuk mengonfigurasi ASM agar berinteraksi dengan Vault dan HSM. Perintah berikut mempersingkat waktu tunggu menjadi 10 detik, karena Istiod tidak akan sepenuhnya siap akibat operasi impor yang tertunda oleh operator.

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

Jalankan perintah berikut untuk menginstal Anthos Service Mesh menggunakan profil asm-multicloud. Jika Anda ingin mengaktifkan fitur opsional yang didukung, sertakan -f dan nama file YAML pada command line berikut. Lihat Mengaktifkan fitur opsional untuk mengetahui informasi selengkapnya.

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"

Konfigurasikan webhook yang memvalidasi agar dapat menemukan layanan istiod dengan label revisi:
```
kubectl apply -f istiod-service.yaml
```
Perintah ini membuat entri layanan yang memungkinkan webhook yang memvalidasi secara otomatis memeriksa konfigurasi sebelum diterapkan.
Pastikan Istiod sudah diinisialisasi dengan benar dan dalam status menunggu.
```
kubectl get pod -l app=istiod -n istio-system
```
Anda akan mendapatkan output seperti berikut:
```
NAME                      READY   STATUS    RESTARTS   AGE
istiod-66ff56d76c-f9p5l   2/3     Running   2          1m27s
```
Lihat bahwa Istiod belum sepenuhnya siap karena container discovery diblokir dan menunggu sertifikat.

Periksa log container Istiod untuk memastikannya berada dalam status yang benar.

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

Anda akan mendapatkan output seperti berikut:

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

Nantikan baris terakhir output seperti berikut:

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

Menandatangani sertifikat untuk Istiod

Download CSR terenkripsi dari rahasia Kubernetes.

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

Mendekripsi 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

Administrator keamanan harus mengambil file csr.pem dan menandatanganinya menggunakan root CA.
Masukkan rantai sertifikat Anda ke root file bernama cert-chain.pem, lalu jalankan perintah berikut.
```
kubectl create secret generic istio-ca-cert --from-file=cert-chain.pem -n istio-system
```

Pastikan Istiod berhasil memuat rantai sertifikat baru dengan memeriksanya di log Istiod.

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

Outputnya mungkin akan mirip dengan berikut ini:

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

sertifikat menengah: -----BEGIN CERTIFICATE----- ... -----END CERTIFICATE-----

root cert: -----BEGIN CERTIFICATE----- ... -----END CERTIFICATE-----

Memverifikasi penginstalan

Gunakan langkah-langkah berikut untuk memverifikasi bahwa penginstalan Anthos Service Mesh Anda berfungsi dengan benar.

Memeriksa komponen bidang kontrol

Pastikan pod bidang kontrol di istio-system sudah berjalan:

kubectl get pod -n istio-system

Output yang diharapkan mirip dengan berikut ini:

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

Memicu panggilan TLS ke layanan dari file bantuan, dan memeriksa sertifikat yang digunakan oleh layanan, menggunakan bookinfo sebagai contohnya.
```
kubectl exec POD -c istio-proxy -- openssl s_client -alpn istio -showcerts -connect details:9080
```
Periksa sertifikat di output, dan Anda akan melihat rantai sertifikat sisi server di output.

Memasukkan proxy file bantuan

Anthos Service Mesh menggunakan proxy file bantuan untuk meningkatkan keamanan, keandalan, dan kemampuan observasi jaringan. Dengan Anthos Service Mesh, fungsi-fungsi ini diabstraksikan dari container utama aplikasi dan diimplementasikan dalam proxy di luar proses umum yang dikirimkan sebagai container terpisah dalam Pod yang sama.

Penginstalan belum selesai sampai Anda mengaktifkan injeksi proxy sidecar otomatis (injeksi otomatis) dan memulai ulang Pod untuk semua workload yang sedang berjalan di cluster sebelum Anda menginstal Anthos Service Mesh.

Untuk mengaktifkan injeksi otomatis, beri label namespace dengan label revisi yang ditetapkan pada istiod saat Anda menginstal Anthos Service Mesh. Label revisi digunakan oleh webhook injektor file bantuan untuk mengaitkan file bantuan yang dimasukkan dengan revisi istiod tertentu. Setelah menambahkan label, semua Pod yang ada di namespace harus dimulai ulang agar sidecar dapat dimasukkan.

Sebelum men-deploy workload baru di namespace baru, pastikan untuk mengonfigurasi injeksi otomatis agar Anthos Service Mesh dapat memantau dan mengamankan traffic.

Untuk mengaktifkan injeksi otomatis:

Gunakan perintah berikut untuk menemukan label revisi di istiod:

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

Outputnya terlihat mirip dengan yang berikut ini:

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

Pada output, di kolom LABELS, catat nilai label revisi istiod, yang mengikuti awalan istio.io/rev=. Dalam contoh ini, nilainya adalah asm-1106-2.

Terapkan label revisi dan hapus label istio-injection jika ada. Dalam perintah berikut, NAMESPACE adalah nama namespace tempat Anda ingin mengaktifkan injeksi otomatis, dan REVISION adalah label revisi yang Anda catat pada langkah sebelumnya.
```
kubectl label namespace NAMESPACE istio-injection- istio.io/rev=REVISION --overwrite
```
Anda dapat mengabaikan pesan "istio-injection not found" di output. Artinya, namespace sebelumnya tidak memiliki label istio-injection, yang akan Anda harapkan dalam penginstalan baru Anthos Service Mesh atau deployment baru. Karena injeksi otomatis gagal jika namespace memiliki istio-injection dan label revisi, semua perintah kubectl label dalam dokumentasi Anthos Service Mesh mencakup penghapusan label istio-injection.
Jika beban kerja berjalan di cluster sebelum Anda menginstal Anthos Service Mesh, mulai ulang Pod untuk memicu injeksi ulang.

Cara memulai ulang Pod bergantung pada aplikasi dan lingkungan cluster tersebut. Misalnya, di lingkungan staging, Anda dapat menghapus semua Pod, yang menyebabkannya dimulai ulang. Namun, di lingkungan produksi, Anda mungkin memiliki proses yang menerapkan deployment berwarna biru-hijau, sehingga Anda dapat memulai ulang Pod dengan aman untuk menghindari gangguan traffic.

Anda dapat menggunakan kubectl untuk melakukan mulai ulang berkelanjutan:
```
kubectl rollout restart deployment -n NAMESPACE
```
Pastikan bahwa Pod Anda telah dikonfigurasi untuk mengarah ke versi baru istiod.
```
kubectl get pods -n NAMESPACE -l istio.io/rev=REVISION
```

Mengonfigurasi alamat IP eksternal

Penginstalan Anthos Service Mesh default mengasumsikan bahwa alamat IP eksternal dialokasikan secara otomatis untuk layanan LoadBalancer. Hal ini tidak berlaku pada GKE di VMware. Oleh karena itu, Anda perlu mengalokasikan alamat IP secara manual untuk resource ingress Gateway Anthos Service Mesh.

Untuk mengonfigurasi alamat IP eksternal, ikuti salah satu bagian di bawah ini, bergantung pada mode load balancing cluster Anda:

Mengonfigurasi mode load balancing terintegrasi

Buka konfigurasi Layanan istio-ingressgateway:
```
kubectl edit svc -n istio-system istio-ingressgateway
```
Konfigurasi untuk layanan istio-ingressgateway akan terbuka di editor teks default shell Anda.

Dalam file, tambahkan baris berikut di bagian blok spesifikasi (spec):

loadBalancerIP: <your static external IP address>

Contoh:

spec:
 loadBalancerIP: 203.0.113.1

Simpan file.

Mengonfigurasi mode load balancing manual

Untuk mengekspos layanan jenis NodePort dengan alamat IP virtual (VIP) di load balancer, dapatkan nilai nodePort terlebih dahulu:

Lihat konfigurasi layanan istio-ingressgateway di shell Anda:

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

Setiap port untuk gateway Anthos Service Mesh akan ditampilkan. Output perintahnya mirip dengan berikut ini:

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

Ekspos port ini melalui load balancer Anda.

Misalnya, port layanan bernama http2 memiliki port 80 dan nodePort 31380. Misalnya alamat node untuk cluster pengguna Anda adalah 192.168.0.10, 192.168.0.11, dan 192.168.0.12, dan VIP load balancer Anda adalah 203.0.113.1.

Konfigurasi load balancer Anda agar traffic yang dikirim ke 203.0.113.1:80 diteruskan ke 192.168.0.10:31380, 192.168.0.11:31380, atau 192.168.0.12:31380. Anda dapat memilih port layanan yang ingin diekspos pada VIP tertentu ini.

Apa langkah selanjutnya?

Men-deploy contoh aplikasi contoh Online Boutique