Anthos Service Mesh dan Traffic Director kini bergabung menjadi Cloud Service Mesh. Untuk mengetahui informasi selengkapnya, lihat ringkasan Cloud Service Mesh.

Halaman ini diterjemahkan oleh Cloud Translation API.

Menyiapkan keamanan layanan dengan gRPC tanpa proxy

Panduan ini menunjukkan cara mengonfigurasi layanan keamanan untuk mesh layanan gRPC tanpa proxy.

Persyaratan

Sebelum mengonfigurasi keamanan layanan untuk mesh layanan tanpa proxy gRPC, pastikan Anda memenuhi persyaratan berikut.

Deployment Anda memenuhi persyaratan dalam Mempersiapkan penyiapan di API perutean layanan dengan Envoy dan workload tanpa proxy.
Anda harus menggunakan xDS v3.
Anda memiliki akses ke fungsi penyedia sertifikat dan versi xDS yang diperlukan dengan salah satu bahasa berikut:
- gRPC Java
- gRPC C++
- gRPC Python
- gRPC Go Anda dapat menemukan versi bahasa yang diperlukan di github
Anda memiliki akses ke generator bootstrap, versi 0.16.0. Image generator bootstrap berada di repositori container. Google Cloud
Anda memenuhi semua prasyarat untuk load balancing mesh layanan tanpa proxy gRPC.
Anda memiliki izin yang memadai untuk membuat atau memperbarui Cloud Service Mesh dan Google Cloud resource service mesh untuk menggunakan keamanan PSM. Untuk mengetahui informasi lengkap tentang izin yang diperlukan, lihat Bersiap untuk menyiapkan Cloud Service Mesh dengan layanan gRPC tanpa proxy.
Anda memiliki izin yang diperlukan untuk menggunakan Certificate Authority Service, yang dijelaskan dalam Membuat certificate authority untuk menerbitkan sertifikat

Mengonfigurasi Identity and Access Management

Anda harus memiliki izin yang diperlukan untuk menggunakan Google Kubernetes Engine. Minimal, Anda harus memiliki peran berikut:

Peran GKE roles/container.clusterAdmin
Peran roles/compute.instanceAdmin Compute Engine
Peran roles/iam.serviceAccountUser

Untuk membuat resource yang diperlukan untuk penyiapan, Anda harus memiliki peran compute.NetworkAdmin. Peran ini berisi semua izin yang diperlukan untuk membuat, memperbarui, menghapus, mencantumkan, dan menggunakan (yaitu, mereferensikan ini di resource lain) resource yang diperlukan. Jika Anda adalah editor-pemilik project, Anda otomatis memiliki peran ini.

Perhatikan bahwa networksecurity.googleapis.com.clientTlsPolicies.use dan networksecurity.googleapis.com.serverTlsPolicies.use tidak diterapkan saat Anda mereferensikan resource ini di resource layanan backend.

Jika hal ini diterapkan pada masa mendatang dan Anda menggunakan peran compute.NetworkAdmin, Anda tidak akan melihat masalah apa pun saat pemeriksaan ini diterapkan.

Jika Anda menggunakan peran khusus dan pemeriksaan ini diterapkan pada masa mendatang, Anda harus memastikan untuk menyertakan izin .use yang sesuai. Jika tidak, di masa mendatang, Anda mungkin mendapati bahwa peran kustom Anda tidak memiliki izin yang diperlukan untuk merujuk ke clientTlsPolicy atau serverTlsPolicy dari layanan backend.

Bersiap untuk melakukan penyiapan

Keamanan mesh layanan tanpa proxy (PSM) menambahkan keamanan ke mesh layanan yang disiapkan untuk load balancing sesuai dengan dokumentasi layanan gRPC tanpa proxy. Di mesh layanan tanpa proxy, klien gRPC menggunakan skema xds: di URI untuk mengakses layanan, yang memungkinkan fitur load balancing PSM dan penemuan endpoint.

Mengupdate klien dan server gRPC ke versi yang benar

Bangun atau bangun ulang aplikasi Anda menggunakan versi gRPC minimum yang didukung untuk bahasa Anda.

Perbarui file bootstrap

Aplikasi gRPC menggunakan satu file bootstrap, yang harus memiliki semua kolom yang diperlukan oleh kode sisi klien dan sisi server gRPC. Generator bootstrap otomatis membuat file bootstrap untuk menyertakan tanda dan nilai yang diperlukan keamanan PSM. Untuk mengetahui informasi selengkapnya, lihat bagian File bootstrap, yang mencakup contoh file bootstrap.

Ringkasan penyiapan

Proses penyiapan ini adalah ekstensi dari penyiapan Cloud Service Mesh dengan layanan gRPC tanpa proxy dan GKE. Langkah-langkah yang tidak diubah dari prosedur penyiapan tersebut dirujuk di mana pun langkah-langkah tersebut berlaku.

Peningkatan utama pada penyiapan Cloud Service Mesh dengan GKE adalah sebagai berikut:

Menyiapkan CA Service, tempat Anda membuat kumpulan CA pribadi dan certificate authority yang diperlukan.
Membuat cluster GKE dengan fitur Workload Identity Federation untuk GKE dan sertifikat mesh serta integrasi Layanan CA.
Mengonfigurasi penerbitan sertifikat mesh di cluster.
Membuat akun layanan klien dan server.
Menyiapkan server contoh yang menggunakan xDS API dan kredensial server xDS untuk mendapatkan konfigurasi keamanan dari Cloud Service Mesh.
Menyiapkan klien contoh yang menggunakan kredensial xDS.
Memperbarui konfigurasi Cloud Service Mesh untuk menyertakan konfigurasi keamanan.

Anda dapat melihat contoh kode untuk menggunakan kredensial xDS di lokasi berikut:

Update Google Cloud CLI

Untuk mengupdate Google Cloud CLI, jalankan perintah berikut:

gcloud components update

Menyiapkan variabel lingkungan

Dalam panduan ini, Anda menggunakan perintah Cloud Shell, dan informasi yang berulang dalam perintah diwakili oleh berbagai variabel lingkungan. Tetapkan nilai spesifik Anda ke variabel lingkungan berikut di lingkungan shell sebelum Anda menjalankan perintah. Setiap baris komentar menunjukkan arti variabel lingkungan terkait.

# Your project ID
PROJECT_ID=PROJECT_ID

# GKE cluster name and zone for this example.
CLUSTER_NAME=CLUSTER_NAME
ZONE=ZONE
gcloud config set compute/zone $ZONE

# GKE cluster URL derived from the above
GKE_CLUSTER_URL="https://container.googleapis.com/v1/projects/${PROJECT_ID}/locations/${ZONE}/clusters/${CLUSTER_NAME}"

# Workload pool to be used with the GKE cluster
WORKLOAD_POOL="${PROJECT_ID}.svc.id.goog"

# Kubernetes namespace to run client and server demo.
K8S_NAMESPACE='default'
DEMO_BACKEND_SERVICE_NAME='grpc-gke-helloworld-service'

# Compute other values
# Project number for your project
PROJNUM=$(gcloud projects describe ${PROJECT_ID} --format="value(projectNumber)")

# VERSION is the GKE cluster version. Install and use the most recent version
# from the rapid release channel and substitute its version for
# CLUSTER_VERSION, for example:
# VERSION=latest available version
# Note that the minimum required cluster version is 1.21.4-gke.1801.
VERSION="CLUSTER_VERSION"
SA_GKE=service-${PROJNUM}@container-engine-robot.iam.gserviceaccount.com

Mengaktifkan akses ke API yang diperlukan

Bagian ini memberi tahu Anda cara mengaktifkan akses ke API yang diperlukan.

Jalankan perintah berikut untuk mengaktifkan Cloud Service Mesh dan API lain yang diperlukan untuk keamanan mesh layanan gRPC tanpa proxy.

gcloud services enable \
    container.googleapis.com \
    cloudresourcemanager.googleapis.com \
    compute.googleapis.com \
    trafficdirector.googleapis.com \
    networkservices.googleapis.com \
    networksecurity.googleapis.com \
    privateca.googleapis.com \
    gkehub.googleapis.com

Jalankan perintah berikut untuk mengizinkan akun layanan default mengakses Cloud Service Mesh Security API.

GSA_EMAIL=$(gcloud iam service-accounts list --format='value(email)' \
    --filter='displayName:Compute Engine default service account')

gcloud projects add-iam-policy-binding ${PROJECT_ID} \
  --member serviceAccount:${GSA_EMAIL} \
   --role roles/trafficdirector.client

Membuat atau mengupdate cluster GKE

Keamanan layanan Cloud Service Mesh bergantung pada integrasi CA Service dengan GKE. Cluster GKE harus memenuhi persyaratan berikut selain persyaratan untuk penyiapan:

Gunakan versi cluster minimum 1.21.4-gke.1801. Jika Anda memerlukan fitur yang ada di versi yang lebih baru, Anda dapat memperoleh versi tersebut dari saluran rilis cepat.
Cluster GKE harus diaktifkan dan dikonfigurasi dengan sertifikat mesh, seperti yang dijelaskan dalam Membuat certificate authority untuk menerbitkan sertifikat.

Buat cluster baru yang menggunakan Workload Identity Federation for GKE. Jika Anda mengupdate cluster yang ada, lanjutkan ke langkah berikutnya. Nilai yang Anda berikan untuk --tags harus cocok dengan nama yang diteruskan ke tanda --target-tags untuk perintah firewall-rules create di bagian Mengonfigurasi Cloud Service Mesh dengan komponen Cloud Load Balancing.

# Create a GKE cluster with GKE managed mesh certificates.
gcloud container clusters create CLUSTER_NAME \
  --release-channel=rapid \
  --scopes=cloud-platform \
  --image-type=cos_containerd \
  --machine-type=e2-standard-2 \
  --zone=ZONE \
  --workload-pool=PROJECT_ID.svc.id.goog \
  --enable-mesh-certificates \
  --cluster-version=CLUSTER_VERSION \
  --enable-ip-alias \
  --tags=allow-health-checks \
  --workload-metadata=GKE_METADATA

Pembuatan cluster mungkin memerlukan waktu beberapa menit.

Jika Anda menggunakan cluster yang ada, aktifkan Workload Identity Federation untuk GKE dan sertifikat mesh GKE. Pastikan cluster dibuat dengan flag --enable-ip-alias, yang tidak dapat digunakan dengan perintah update.
```
gcloud container clusters update CLUSTER_NAME \
  --enable-mesh-certificates
```
Jalankan perintah berikut untuk beralih ke cluster baru sebagai cluster default untuk perintah kubectl Anda:
```
gcloud container clusters get-credentials CLUSTER_NAME \
  --zone ZONE
```

Mendaftarkan cluster ke fleet

Daftarkan cluster yang Anda buat atau update di Membuat cluster GKE dengan fleet. Mendaftarkan cluster akan mempermudah Anda mengonfigurasi cluster di beberapa project.

Perhatikan bahwa setiap langkah ini dapat memerlukan waktu hingga sepuluh menit untuk diselesaikan.

Daftarkan cluster Anda ke fleet:
```
gcloud container fleet memberships register CLUSTER_NAME \
  --gke-cluster=ZONE/CLUSTER_NAME \
  --enable-workload-identity --install-connect-agent \
  --manifest-output-file=MANIFEST-FILE_NAME
```
Ganti variabel sebagai berikut:
- CLUSTER_NAME: Nama cluster Anda.
- ZONE: Zona cluster Anda.
- MANIFEST-FILE_NAME: Jalur tempat perintah ini membuat manifes untuk pendaftaran.
Jika proses pendaftaran berhasil, Anda akan melihat pesan seperti berikut:
```
Finished registering the cluster CLUSTER_NAME with the fleet.
```

Terapkan file manifes yang dihasilkan ke cluster Anda:

kubectl apply -f MANIFEST-FILE_NAME

Jika proses permohonan berhasil, Anda akan melihat pesan seperti berikut:

namespace/gke-connect created
serviceaccount/connect-agent-sa created
podsecuritypolicy.policy/gkeconnect-psp created
role.rbac.authorization.k8s.io/gkeconnect-psp:role created
rolebinding.rbac.authorization.k8s.io/gkeconnect-psp:rolebinding created
role.rbac.authorization.k8s.io/agent-updater created
rolebinding.rbac.authorization.k8s.io/agent-updater created
role.rbac.authorization.k8s.io/gke-connect-agent-20210416-01-00 created
clusterrole.rbac.authorization.k8s.io/gke-connect-impersonation-20210416-01-00 created
clusterrolebinding.rbac.authorization.k8s.io/gke-connect-impersonation-20210416-01-00 created
clusterrolebinding.rbac.authorization.k8s.io/gke-connect-feature-authorizer-20210416-01-00 created
rolebinding.rbac.authorization.k8s.io/gke-connect-agent-20210416-01-00 created
role.rbac.authorization.k8s.io/gke-connect-namespace-getter created
rolebinding.rbac.authorization.k8s.io/gke-connect-namespace-getter created
secret/http-proxy created
deployment.apps/gke-connect-agent-20210416-01-00 created
service/gke-connect-monitoring created
secret/creds-gcp create

Dapatkan resource keanggotaan dari cluster:
```
kubectl get memberships membership -o yaml
```
Output harus menyertakan Workload Identity Pool yang ditetapkan oleh armada, dengan PROJECT_ID adalah project ID Anda:
```
workload_identity_pool: PROJECT_ID.svc.id.goog
```
Artinya, cluster berhasil didaftarkan.

Membuat certificate authority untuk menerbitkan sertifikat

Untuk menerbitkan sertifikat ke Pod Anda, buat kumpulan CA Service dan certificate authority (CA) berikut:

Root CA. Ini adalah root kepercayaan untuk semua sertifikat mesh yang diterbitkan. Anda dapat menggunakan CA root yang ada jika Anda memilikinya. Buat CA root di tingkat enterprise, yang ditujukan untuk penerbitan sertifikat berumur panjang dan bervolume rendah.
CA subordinat. CA ini menerbitkan sertifikat untuk workload. Buat CA bawahan di region tempat cluster Anda di-deploy. Buat CA subordinat di tingkat devops, yang ditujukan untuk penerbitan sertifikat bervolume tinggi dan berumur pendek.

Membuat CA subordinat bersifat opsional, tetapi sebaiknya Anda membuat CA subordinat daripada menggunakan CA root untuk menerbitkan sertifikat mesh GKE. Jika Anda memutuskan untuk menggunakan CA root untuk menerbitkan sertifikat mesh, pastikan mode penerbitan berbasis konfigurasi default tetap diizinkan.

CA subordinat dapat berada di region yang berbeda dengan cluster Anda, tetapi kami sangat merekomendasikan untuk membuatnya di region yang sama dengan cluster Anda guna mengoptimalkan performa. Namun, Anda dapat membuat CA root dan CA subordinat di region yang berbeda tanpa memengaruhi performa atau ketersediaan.

Region ini didukung untuk Layanan CA:

Nama region	Deskripsi region
`asia-east1`	Taiwan
`asia-east2`	Hong Kong
`asia-northeast1`	Tokyo
`asia-northeast2`	Osaka
`asia-northeast3`	Seoul
`asia-south1`	Mumbai
`asia-south2`	Delhi
`asia-southeast1`	Singapura
`asia-southeast2`	Jakarta
`australia-southeast1`	Sydney
`australia-southeast2`	Melbourne
`europe-central2`	Warsawa
`europe-north1`	Finlandia
`europe-southwest1`	Madrid
`europe-west1`	Belgia
`europe-west2`	London
`europe-west3`	Frankfurt
`europe-west4`	Belanda
`europe-west6`	Zürich
`europe-west8`	Milan
`europe-west9`	Paris
`europe-west10`	Berlin
`europe-west12`	Turin
`me-central1`	Doha
`me-central2`	Dammam
`me-west1`	Tel Aviv
`northamerica-northeast1`	Montréal
`northamerica-northeast2`	Toronto
`southamerica-east1`	Sao Paulo
`southamerica-west1`	Santiago
`us-central1`	Iowa
`us-east1`	Carolina Selatan
`us-east4`	Northern Virginia
`us-east5`	Columbus
`us-south1`	Dallas
`us-west1`	Oregon
`us-west2`	Los Angeles
`us-west3`	Salt Lake City
`us-west4`	Las Vegas

Daftar lokasi yang didukung juga dapat diperiksa dengan menjalankan perintah berikut:

gcloud privateca locations list

Berikan IAM roles/privateca.caManager kepada individu yang membuat kumpulan CA dan CA. Perhatikan bahwa untuk MEMBER, format yang benar adalah user:userid@example.com. Jika orang tersebut adalah pengguna saat ini, Anda dapat memperoleh ID pengguna saat ini dengan perintah shell $(gcloud auth list --filter=status:ACTIVE --format="value(account)").
```
gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=MEMBER \
  --role=roles/privateca.caManager
```
Berikan peran role/privateca.admin untuk Layanan CA kepada individu yang perlu mengubah kebijakan IAM, dengan MEMBER adalah individu yang memerlukan akses ini, khususnya, individu yang melakukan langkah-langkah berikut yang memberikan peran privateca.auditor dan privateca.certificateManager:
```
gcloud projects add-iam-policy-binding PROJECT_ID \
  --member=MEMBER \
  --role=roles/privateca.admin
```

Buat kumpulan Layanan CA root.

gcloud privateca pools create ROOT_CA_POOL_NAME \
  --location ROOT_CA_POOL_LOCATION \
  --tier enterprise

Buat CA root.

gcloud privateca roots create ROOT_CA_NAME --pool ROOT_CA_POOL_NAME \
  --subject "CN=ROOT_CA_NAME, O=ROOT_CA_ORGANIZATION" \
  --key-algorithm="ec-p256-sha256" \
  --max-chain-length=1 \
  --location ROOT_CA_POOL_LOCATION

Untuk penyiapan demonstrasi ini, gunakan nilai berikut untuk variabel:

ROOT_CA_POOL_NAME=td_sec_pool
ROOT_CA_NAME=pkcs2-ca
ROOT_CA_POOL_LOCATION=us-east1
ROOT_CA_ORGANIZATION="TestCorpLLC"

Buat kumpulan subordinat dan CA subordinat. Pastikan mode penerbitan berbasis konfigurasi default tetap diizinkan.

gcloud privateca pools create SUBORDINATE_CA_POOL_NAME \
  --location SUBORDINATE_CA_POOL_LOCATION \
  --tier devops

gcloud privateca subordinates create SUBORDINATE_CA_NAME \
  --pool SUBORDINATE_CA_POOL_NAME \
  --location SUBORDINATE_CA_POOL_LOCATION \
  --issuer-pool ROOT_CA_POOL_NAME \
  --issuer-location ROOT_CA_POOL_LOCATION \
  --subject "CN=SUBORDINATE_CA_NAME, O=SUBORDINATE_CA_ORGANIZATION" \
  --key-algorithm "ec-p256-sha256" \
  --use-preset-profile subordinate_mtls_pathlen_0

Untuk penyiapan demonstrasi ini, gunakan nilai berikut untuk variabel:

SUBORDINATE_CA_POOL_NAME="td-ca-pool"
SUBORDINATE_CA_POOL_LOCATION=us-east1
SUBORDINATE_CA_NAME="td-ca"
SUBORDINATE_CA_ORGANIZATION="TestCorpLLC"
ROOT_CA_POOL_NAME=td_sec_pool
ROOT_CA_POOL_LOCATION=us-east1

Berikan peran IAM privateca.auditor untuk kumpulan CA root agar memungkinkan akses dari akun layanan GKE:

gcloud privateca pools add-iam-policy-binding ROOT_CA_POOL_NAME \
 --location ROOT_CA_POOL_LOCATION \
 --role roles/privateca.auditor \
 --member="serviceAccount:service-PROJNUM@container-engine-robot.iam.gserviceaccount.com"

Berikan peran IAM privateca.certificateManager untuk kumpulan CA subordinat guna mengizinkan akses dari akun layanan GKE:

gcloud privateca pools add-iam-policy-binding SUBORDINATE_CA_POOL_NAME \
  --location SUBORDINATE_CA_POOL_LOCATION \
  --role roles/privateca.certificateManager \
  --member="serviceAccount:service-PROJNUM@container-engine-robot.iam.gserviceaccount.com"

Simpan konfigurasi YAML WorkloadCertificateConfig berikut untuk memberi tahu cluster Anda cara menerbitkan sertifikat mesh:

apiVersion: security.cloud.google.com/v1
kind: WorkloadCertificateConfig
metadata:
  name: default
spec:
  # Required. The CA service that issues your certificates.
  certificateAuthorityConfig:
    certificateAuthorityServiceConfig:
      endpointURI: ISSUING_CA_POOL_URI

  # Required. The key algorithm to use. Choice of RSA or ECDSA.
  #
  # To maximize compatibility with various TLS stacks, your workloads
  # should use keys of the same family as your root and subordinate CAs.
  #
  # To use RSA, specify configuration such as:
  #   keyAlgorithm:
  #     rsa:
  #       modulusSize: 4096
  #
  # Currently, the only supported ECDSA curves are "P256" and "P384", and the only
  # supported RSA modulus sizes are 2048, 3072 and 4096.
  keyAlgorithm:
    rsa:
      modulusSize: 4096

  # Optional. Validity duration of issued certificates, in seconds.
  #
  # Defaults to 86400 (1 day) if not specified.
  validityDurationSeconds: 86400

  # Optional. Try to start rotating the certificate once this
  # percentage of validityDurationSeconds is remaining.
  #
  # Defaults to 50 if not specified.
  rotationWindowPercentage: 50

Ganti kode berikut:

Project ID project tempat cluster Anda berjalan:
```
PROJECT_ID
```
URI yang sepenuhnya memenuhi syarat dari CA yang menerbitkan sertifikat mesh Anda (ISSUING_CA_POOL_URI). Ini bisa berupa CA bawahan (direkomendasikan) atau CA root Anda. Formatnya adalah:
```
//privateca.googleapis.com/projects/PROJECT_ID/locations/SUBORDINATE_CA_POOL_LOCATION/caPools/SUBORDINATE_CA_POOL_NAME
```

Simpan konfigurasi YAML TrustConfig berikut untuk memberi tahu cluster Anda cara memercayai sertifikat yang diterbitkan:

apiVersion: security.cloud.google.com/v1
kind: TrustConfig
metadata:
  name: default
spec:
  # You must include a trustStores entry for the trust domain that
  # your cluster is enrolled in.
  trustStores:
  - trustDomain: PROJECT_ID.svc.id.goog
    # Trust identities in this trustDomain if they appear in a certificate
    # that chains up to this root CA.
    trustAnchors:
    - certificateAuthorityServiceURI: ROOT_CA_POOL_URI

Ganti kode berikut:

Project ID project tempat cluster Anda berjalan:
```
PROJECT_ID
```

URI yang sepenuhnya memenuhi syarat dari kumpulan CA root (ROOT_CA_POOL_URI). Formatnya adalah:

//privateca.googleapis.com/projects/PROJECT_ID/locations/ROOT_CA_POOL_LOCATION/caPools/ROOT_CA_POOL_NAME

Terapkan konfigurasi ke cluster Anda:

kubectl apply -f WorkloadCertificateConfig.yaml
kubectl apply -f TrustConfig.yaml

Membuat layanan gRPC tanpa proxy dengan NEG

Untuk keamanan PSM, Anda memerlukan server gRPC tanpa proxy yang dapat menggunakan xDS untuk mendapatkan konfigurasi keamanan dari Cloud Service Mesh. Langkah ini mirip dengan Mengonfigurasi layanan GKE dengan NEG dalam panduan penyiapan load balancing PSM, tetapi Anda menggunakan server helloworld yang mendukung xDS dalam contoh xDS di repositori grpc-java, bukan image java-example-hostname.

Anda akan membangun dan menjalankan server ini dalam container yang dibuat dari image openjdk:8-jdk. Anda juga menggunakan fitur NEG bernama, yang memungkinkan Anda menentukan nama untuk NEG. Tindakan ini akan menyederhanakan langkah-langkah selanjutnya karena deployment Anda mengetahui nama NEG tanpa harus mencarinya.

Berikut adalah contoh lengkap spesifikasi Kubernetes server gRPC. Perhatikan hal berikut:

Spec membuat akun layanan Kubernetes example-grpc-server yang digunakan oleh Pod server gRPC.
Spesifikasi menggunakan kolom name dalam anotasi cloud.google.com/neg layanan untuk menentukan nama NEG example-grpc-server.
Variabel ${PROJNUM} mewakili nomor project Anda.
Spesifikasi menggunakan bagian initContainers untuk menjalankan generator bootstrap guna mengisi file bootstrap yang dibutuhkan library gRPC tanpa proxy. File bootstrap ini berada di /tmp/grpc-xds/td-grpc-bootstrap.json dalam container server gRPC yang disebut example-grpc-server.

Tambahkan anotasi berikut ke spesifikasi Pod Anda:

 annotations:
   security.cloud.google.com/use-workload-certificates: ""

Anda dapat melihat penempatan yang benar dalam spesifikasi lengkap berikut.

Saat pembuatan, setiap Pod mendapatkan volume di /var/run/secrets/workload-spiffe-credentials. Volume ini berisi hal berikut:

private_key.pem adalah kunci pribadi yang dibuat secara otomatis.
certificates.pem adalah kumpulan sertifikat berformat PEM yang dapat ditampilkan ke Pod lain sebagai rantai sertifikat klien, atau digunakan sebagai rantai sertifikat server.
ca_certificates.pem adalah kumpulan sertifikat berformat PEM yang akan digunakan sebagai anchor kepercayaan saat memvalidasi rantai sertifikat klien yang ditampilkan oleh Pod lain, atau rantai sertifikat server yang diterima saat terhubung ke Pod lain.

Perhatikan bahwa ca_certificates.pem berisi sertifikat untuk domain tepercaya lokal untuk workload, yang merupakan kumpulan workload cluster.

Sertifikat leaf di certificates.pem berisi pernyataan identitas SPIFFE teks biasa berikut:

spiffe://WORKLOAD_POOL/ns/NAMESPACE/sa/KUBERNETES_SERVICE_ACCOUNT

Dalam pernyataan ini:

WORKLOAD_POOL adalah nama kumpulan workload cluster.
NAMESPACE adalah namespace akun layanan Kubernetes Anda.
KUBERNETES_SERVICE_ACCOUNT adalah nama akun layanan Kubernetes Anda.

Petunjuk berikut untuk bahasa Anda membuat spesifikasi yang akan digunakan dalam contoh ini.

Java

Jalankan perintah berikut untuk memastikan nomor project ditetapkan dengan benar:

if [ -z "$PROJNUM" ] ; then export PROJNUM=$(gcloud projects describe $(gcloud info --format='value(config.project)') --format="value(projectNumber)") ; fi ; echo $PROJNUM

Buat spesifikasi:

cat << EOF > example-grpc-server.yaml
apiVersion: v1
kind: ServiceAccount
metadata:
 name: example-grpc-server
 namespace: default
 annotations:
   iam.gke.io/gcp-service-account: ${PROJNUM}-compute@developer.gserviceaccount.com
---
apiVersion: v1
kind: Service
metadata:
 name: example-grpc-server
 namespace: default
 labels:
   k8s-app: example-grpc-server
 annotations:
   cloud.google.com/neg: '{"exposed_ports":{"8080":{"name": "example-grpc-server"}}}'
spec:
 ports:
 - name: helloworld
   port: 8080
   protocol: TCP
   targetPort: 50051
 selector:
   k8s-app: example-grpc-server
 type: ClusterIP
---
apiVersion: apps/v1
kind: Deployment
metadata:
 name: example-grpc-server
 namespace: default
 labels:
   k8s-app: example-grpc-server
spec:
 replicas: 1
 selector:
   matchLabels:
     k8s-app: example-grpc-server
 strategy: {}
 template:
   metadata:
     annotations:
        security.cloud.google.com/use-workload-certificates: ""
     labels:
       k8s-app: example-grpc-server
   spec:
     containers:
     - image: openjdk:8-jdk
       imagePullPolicy: IfNotPresent
       name: example-grpc-server
       command:
       - /bin/sleep
       - inf
       env:
       - name: GRPC_XDS_BOOTSTRAP
         value: "/tmp/grpc-xds/td-grpc-bootstrap.json"
       ports:
       - protocol: TCP
         containerPort: 50051
       resources:
         limits:
           cpu: 800m
           memory: 512Mi
         requests:
           cpu: 100m
           memory: 512Mi
       volumeMounts:
       - name: grpc-td-conf
         mountPath: /tmp/grpc-xds/
     initContainers:
     - name: grpc-td-init
       image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.16.0
       imagePullPolicy: Always
       args:
       - --config-mesh-experimental
       - "grpc-mesh"
       - --output
       - "/tmp/bootstrap/td-grpc-bootstrap.json"
       - --node-metadata=app=helloworld
       resources:
         limits:
           cpu: 100m
           memory: 100Mi
         requests:
           cpu: 10m
           memory: 100Mi
       volumeMounts:
       - name: grpc-td-conf
         mountPath: /tmp/bootstrap/
     serviceAccountName: example-grpc-server
     volumes:
     - name: grpc-td-conf
       emptyDir:
         medium: Memory
EOF

C++

Jalankan perintah berikut untuk memastikan nomor project ditetapkan dengan benar:

if [ -z "$PROJNUM" ] ; then export PROJNUM=$(gcloud projects describe $(gcloud info --format='value(config.project)') --format="value(projectNumber)") ; fi ; echo $PROJNUM

Buat spesifikasi:

cat << EOF > example-grpc-server.yaml
apiVersion: v1
kind: ServiceAccount
metadata:
 name: example-grpc-server
 namespace: default
 annotations:
   iam.gke.io/gcp-service-account: ${PROJNUM}-compute@developer.gserviceaccount.com
---
apiVersion: v1
kind: Service
metadata:
 name: example-grpc-server
 namespace: default
 labels:
   k8s-app: example-grpc-server
 annotations:
   cloud.google.com/neg: '{"exposed_ports":{"8080":{"name": "example-grpc-server"}}}'
spec:
 ports:
 - name: helloworld
   port: 8080
   protocol: TCP
   targetPort: 50051
 selector:
   k8s-app: example-grpc-server
 type: ClusterIP
---
apiVersion: apps/v1
kind: Deployment
metadata:
 name: example-grpc-server
 namespace: default
 labels:
   k8s-app: example-grpc-server
spec:
 replicas: 1
 selector:
   matchLabels:
     k8s-app: example-grpc-server
 strategy: {}
 template:
   metadata:
     annotations:
        security.cloud.google.com/use-workload-certificates: ""
     labels:
       k8s-app: example-grpc-server
   spec:
     containers:
     - image: phusion/baseimage:18.04-1.0.0
       imagePullPolicy: IfNotPresent
       name: example-grpc-server
       command:
       - /bin/sleep
       - inf
       env:
       - name: GRPC_XDS_BOOTSTRAP
         value: "/tmp/grpc-xds/td-grpc-bootstrap.json"
       ports:
       - protocol: TCP
         containerPort: 50051
       resources:
         limits:
           cpu: 8
           memory: 8Gi
         requests:
           cpu: 300m
           memory: 512Mi
       volumeMounts:
       - name: grpc-td-conf
         mountPath: /tmp/grpc-xds/
     initContainers:
     - name: grpc-td-init
       image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.16.0
       imagePullPolicy: Always
       args:
       - --config-mesh-experimental
       - "grpc-mesh"
       - --output
       - "/tmp/bootstrap/td-grpc-bootstrap.json"
       - --node-metadata=app=helloworld
       resources:
         limits:
           cpu: 100m
           memory: 100Mi
         requests:
           cpu: 10m
           memory: 100Mi
       volumeMounts:
       - name: grpc-td-conf
         mountPath: /tmp/bootstrap/
     serviceAccountName: example-grpc-server
     volumes:
     - name: grpc-td-conf
       emptyDir:
         medium: Memory
EOF

Python

Jalankan perintah berikut untuk memastikan nomor project ditetapkan dengan benar:

if [ -z "$PROJNUM" ] ; then export PROJNUM=$(gcloud projects describe $(gcloud info --format='value(config.project)') --format="value(projectNumber)") ; fi ; echo $PROJNUM

Buat spesifikasi:

cat << EOF > example-grpc-server.yaml
apiVersion: v1
kind: ServiceAccount
metadata:
 name: example-grpc-server
 namespace: default
 annotations:
   iam.gke.io/gcp-service-account: ${PROJNUM}-compute@developer.gserviceaccount.com
---
apiVersion: v1
kind: Service
metadata:
 name: example-grpc-server
 namespace: default
 labels:
   k8s-app: example-grpc-server
 annotations:
   cloud.google.com/neg: '{"exposed_ports":{"8080":{"name": "example-grpc-server"}}}'
spec:
 ports:
 - name: helloworld
   port: 8080
   protocol: TCP
   targetPort: 50051
 selector:
   k8s-app: example-grpc-server
 type: ClusterIP
---
apiVersion: apps/v1
kind: Deployment
metadata:
 name: example-grpc-server
 namespace: default
 labels:
   k8s-app: example-grpc-server
spec:
 replicas: 1
 selector:
   matchLabels:
     k8s-app: example-grpc-server
 strategy: {}
 template:
   metadata:
     annotations:
        security.cloud.google.com/use-workload-certificates: ""
     labels:
       k8s-app: example-grpc-server
   spec:
     containers:
     - image: phusion/baseimage:18.04-1.0.0
       imagePullPolicy: IfNotPresent
       name: example-grpc-server
       command:
       - /bin/sleep
       - inf
       env:
       - name: GRPC_XDS_BOOTSTRAP
         value: "/tmp/grpc-xds/td-grpc-bootstrap.json"
       ports:
       - protocol: TCP
         containerPort: 50051
       resources:
         limits:
           cpu: 8
           memory: 8Gi
         requests:
           cpu: 300m
           memory: 512Mi
       volumeMounts:
       - name: grpc-td-conf
         mountPath: /tmp/grpc-xds/
     initContainers:
     - name: grpc-td-init
       image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.16.0
       imagePullPolicy: Always
       args:
       - --config-mesh-experimental
       - "grpc-mesh"
       - --output
       - "/tmp/bootstrap/td-grpc-bootstrap.json"
       - --node-metadata=app=helloworld
       resources:
         limits:
           cpu: 100m
           memory: 100Mi
         requests:
           cpu: 10m
           memory: 100Mi
       volumeMounts:
       - name: grpc-td-conf
         mountPath: /tmp/bootstrap/
     serviceAccountName: example-grpc-server
     volumes:
     - name: grpc-td-conf
       emptyDir:
         medium: Memory
EOF

Go

Jalankan perintah berikut untuk memastikan nomor project ditetapkan dengan benar:

if [ -z "$PROJNUM" ] ; then export PROJNUM=$(gcloud projects describe $(gcloud info --format='value(config.project)') --format="value(projectNumber)") ; fi ; echo $PROJNUM

Buat spesifikasi:

cat << EOF > example-grpc-server.yaml
apiVersion: v1
kind: ServiceAccount
metadata:
 name: example-grpc-server
 namespace: default
 annotations:
   iam.gke.io/gcp-service-account: ${PROJNUM}-compute@developer.gserviceaccount.com
---
apiVersion: v1
kind: Service
metadata:
 name: example-grpc-server
 namespace: default
 labels:
   k8s-app: example-grpc-server
 annotations:
   cloud.google.com/neg: '{"exposed_ports":{"8080":{"name": "example-grpc-server"}}}'
spec:
 ports:
 - name: helloworld
   port: 8080
   protocol: TCP
   targetPort: 50051
 selector:
   k8s-app: example-grpc-server
 type: ClusterIP
---
apiVersion: apps/v1
kind: Deployment
metadata:
 name: example-grpc-server
 namespace: default
 labels:
   k8s-app: example-grpc-server
spec:
 replicas: 1
 selector:
   matchLabels:
     k8s-app: example-grpc-server
 strategy: {}
 template:
   metadata:
     annotations:
        security.cloud.google.com/use-workload-certificates: ""
     labels:
       k8s-app: example-grpc-server
   spec:
     containers:
     - image: golang:1.16-alpine
       imagePullPolicy: IfNotPresent
       name: example-grpc-server
       command:
       - /bin/sleep
       - inf
       env:
       - name: GRPC_XDS_BOOTSTRAP
         value: "/tmp/grpc-xds/td-grpc-bootstrap.json"
       ports:
       - protocol: TCP
         containerPort: 50051
       resources:
         limits:
           cpu: 8
           memory: 8Gi
         requests:
           cpu: 300m
           memory: 512Mi
       volumeMounts:
       - name: grpc-td-conf
         mountPath: /tmp/grpc-xds/
     initContainers:
     - name: grpc-td-init
       image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.16.0
       imagePullPolicy: Always
       args:
       - --config-mesh-experimental
       - "grpc-mesh"
       - --output
       - "/tmp/bootstrap/td-grpc-bootstrap.json"
       - --node-metadata=app=helloworld
       resources:
         limits:
           cpu: 100m
           memory: 100Mi
         requests:
           cpu: 10m
           memory: 100Mi
       volumeMounts:
       - name: grpc-td-conf
         mountPath: /tmp/bootstrap/
     serviceAccountName: example-grpc-server
     volumes:
     - name: grpc-td-conf
       emptyDir:
         medium: Memory
EOF

Selesaikan prosesnya sebagai berikut.

Terapkan spesifikasi:

kubectl apply -f example-grpc-server.yaml

Berikan peran yang diperlukan ke akun layanan:

gcloud iam service-accounts add-iam-policy-binding \
  --role roles/iam.workloadIdentityUser \
  --member "serviceAccount:${PROJECT_ID}.svc.id.goog[default/example-grpc-server]" \
  ${PROJNUM}-compute@developer.gserviceaccount.com

gcloud projects add-iam-policy-binding ${PROJECT_ID} \
  --member "serviceAccount:${PROJECT_ID}.svc.id.goog[default/example-grpc-server]" \
  --role roles/trafficdirector.client

Jalankan perintah ini untuk memverifikasi bahwa layanan dan Pod telah dibuat dengan benar:
```
kubectl get deploy/example-grpc-server
kubectl get svc/example-grpc-server
```

Pastikan nama NEG sudah benar:

gcloud compute network-endpoint-groups list \
    --filter "name=example-grpc-server" --format "value(name)"

Perintah akan menampilkan nama NEG example-grpc-server.

Mengonfigurasi Cloud Service Mesh dengan Google Cloud komponen load balancing

Langkah-langkah di bagian ini mirip dengan langkah-langkah di Mengonfigurasi Cloud Service Mesh dengan komponen load balancing, tetapi ada beberapa perubahan, seperti yang dijelaskan di bagian berikut.

Buat health check, aturan firewall, dan layanan backend

Jika server gRPC dikonfigurasi untuk menggunakan mTLS, health check gRPC tidak akan berfungsi karena klien health check tidak dapat memberikan sertifikat klien yang valid ke server. Anda dapat mengatasi hal ini dengan salah satu dari dua cara berikut.

Dalam pendekatan pertama, Anda membuat server membuat port penayangan tambahan yang ditetapkan sebagai port health check. Ini dilampirkan ke layanan health check khusus, sebagai teks biasa atau TLS ke port tersebut.

Server contoh xDS helloworld menggunakan PORT_NUMBER + 1 sebagai port health check teks biasa. Contoh ini menggunakan 50052 sebagai port health check karena 50051 adalah port server aplikasi gRPC.

Pada pendekatan kedua, Anda mengonfigurasi health check untuk memeriksa hanya konektivitas TCP ke port penayangan aplikasi. Hal ini hanya memeriksa konektivitas, dan juga menghasilkan traffic yang tidak perlu ke server saat terjadi handshake TLS yang gagal. Oleh karena itu, sebaiknya gunakan pendekatan pertama.

Buat health check. Perhatikan bahwa pemeriksaan kondisi tidak dimulai hingga Anda membuat dan memulai server.
- Jika Anda membuat port penayangan yang ditetapkan untuk health check, yang merupakan pendekatan yang kami rekomendasikan, gunakan perintah ini:
```
gcloud compute health-checks create grpc grpc-gke-helloworld-hc \
 --enable-logging --port 50052
```
- Jika Anda membuat health check TCP, yang tidak kami rekomendasikan, gunakan perintah ini:
```
gcloud compute health-checks create tcp grpc-gke-helloworld-hc \
--use-serving-port
```

Buat firewall. Pastikan nilai --target-tags cocok dengan nilai yang Anda berikan untuk --tags di bagian Membuat atau mengupdate cluster GKE.

gcloud compute firewall-rules create grpc-gke-allow-health-checks \
  --network default --action allow --direction INGRESS \
  --source-ranges 35.191.0.0/16,130.211.0.0/22 \
  --target-tags allow-health-checks \
  --rules tcp:50051-50052

Buat layanan backend:

gcloud compute backend-services create grpc-gke-helloworld-service \
   --global \
   --load-balancing-scheme=INTERNAL_SELF_MANAGED \
   --protocol=GRPC \
   --health-checks grpc-gke-helloworld-hc

Tambahkan NEG ke layanan backend:

gcloud compute backend-services add-backend grpc-gke-helloworld-service \
   --global \
   --network-endpoint-group example-grpc-server \
   --network-endpoint-group-zone ${ZONE} \
   --balancing-mode RATE \
   --max-rate-per-endpoint 5

Membuat resource `Mesh` dan `GRPCRoute`

Hal ini mirip dengan cara Anda menyiapkan resource Mesh dan GRPCRoute di Menyiapkan layanan gRPC tanpa proxy.

Buat spesifikasi Mesh dan simpan dalam file bernama mesh.yaml.
```
name: grpc-mesh
```

Impor resource Mesh dari spesifikasi.

gcloud network-services meshes import grpc-mesh \
  --source=mesh.yaml \
  --location=global

Buat spesifikasi GRPCRoute dan simpan dalam file bernama grpc_route.yaml.

name: helloworld-grpc-route
hostnames:
- helloworld-gke:8000
meshes:
- projects/PROJECT_NUMBER/locations/global/meshes/grpc-mesh
rules:
- action:
    destinations:
    - serviceName: projects/PROJECT_NUMBER/locations/global/backendServices/grpc-gke-helloworld-service

Impor resource GRPCRoute dari spesifikasi grpc_route.yaml.

gcloud network-services grpc-routes import helloworld-grpc-route \
  --source=grpc_route.yaml \
  --location=global

Mengonfigurasi Cloud Service Mesh dengan Keamanan gRPC tanpa proxy

Contoh ini menunjukkan cara mengonfigurasi mTLS di sisi klien dan server.

Format untuk referensi kebijakan

Perhatikan format wajib berikut untuk merujuk ke kebijakan TLS server dan TLS klien:

projects/PROJECT_ID/locations/global/[serverTlsPolicies|clientTlsPolicies]/[server-tls-policy|client-mtls-policy]

Contoh:

projects/PROJECT_ID/locations/global/serverTlsPolicies/server-tls-policy

projects/PROJECT_ID/locations/global/clientTlsPolicies/client-mtls-policy

Mengonfigurasi mTLS di sisi server

Pertama, Anda membuat kebijakan TLS server. Kebijakan meminta sisi server gRPC untuk menggunakan konfigurasi plugin certificateProvicerInstance yang diidentifikasi berdasarkan nama google_cloud_private_spiffe untuk sertifikat identitas, yang merupakan bagian dari serverCertificate. Bagian mtlsPolicy menunjukkan keamanan mTLS dan menggunakan google_cloud_private_spiffe yang sama dengan konfigurasi plugin untuk clientValidationCa, yang merupakan spesifikasi sertifikat root (validasi).

Selanjutnya, Anda membuat kebijakan endpoint. Hal ini menentukan bahwa backend, misalnya server gRPC, yang menggunakan port 50051 dengan label metadata apa pun atau tanpa label, menerima kebijakan TLS server terlampir yang bernama server-mtls-policy. Anda menentukan label metadata menggunakan MATCH_ALL atau nilai yang didukung. Label metadata yang didukung dapat ditemukan di kolom endpointMatcher.metadataLabelMatcher.metadataLabelMatchCriteria dalam Dokumen NetworkServicesEndpointPolicy. Anda membuat kebijakan endpoint dengan file sementara ep-mtls-psms.yaml yang berisi nilai untuk resource kebijakan endpoint menggunakan kebijakan yang telah Anda tentukan.

Buat file sementara server-mtls-policy.yaml di direktori saat ini dengan nilai resource kebijakan TLS server:

name: "projects/PROJECT_ID/locations/global/serverTlsPolicies/server-mtls-policy"
serverCertificate:
  certificateProviderInstance:
    pluginInstance: google_cloud_private_spiffe
mtlsPolicy:
  clientValidationCa:
  - certificateProviderInstance:
      pluginInstance: google_cloud_private_spiffe

Buat resource kebijakan TLS server bernama server-mtls-policy dengan mengimpor file sementara server-mtls-policy.yaml:

gcloud network-security server-tls-policies import server-mtls-policy \
  --source=server-mtls-policy.yaml --location=global

Buat kebijakan endpoint dengan membuat file sementara ep-mtls-psms.yaml:

name: "ep-mtls-psms"
type: "GRPC_SERVER"
serverTlsPolicy: "projects/PROJECT_ID/locations/global/serverTlsPolicies/server-mtls-policy"
trafficPortSelector:
  ports:
  - "50051"
endpointMatcher:
  metadataLabelMatcher:
    metadataLabelMatchCriteria: "MATCH_ALL"
    metadataLabels:
    - labelName: app
      labelValue: helloworld

Buat resource kebijakan endpoint dengan mengimpor file ep-mtls-psms.yaml:

gcloud beta network-services endpoint-policies import ep-mtls-psms \
  --source=ep-mtls-psms.yaml --location=global

Mengonfigurasi mTLS di sisi klien

Kebijakan keamanan sisi klien dilampirkan ke layanan backend. Saat klien mengakses backend (server gRPC) melalui layanan backend, kebijakan keamanan sisi klien yang terlampir akan dikirim ke klien.

Buat konten resource kebijakan TLS klien dalam file sementara bernama client-mtls-policy.yaml di direktori saat ini:

name: "client-mtls-policy"
clientCertificate:
  certificateProviderInstance:
    pluginInstance: google_cloud_private_spiffe
serverValidationCa:
- certificateProviderInstance:
    pluginInstance: google_cloud_private_spiffe

Buat resource kebijakan TLS klien yang disebut client-mtls-policy dengan mengimpor file sementara client-mtls-policy.yaml:

gcloud network-security client-tls-policies import client-mtls-policy \
  --source=client-mtls-policy.yaml --location=global

Buat cuplikan dalam file sementara untuk mereferensikan kebijakan ini dan tambahkan detail untuk subjectAltNames dalam pesan SecuritySettings seperti dalam contoh berikut. Ganti ${PROJECT_ID} dengan nilai project ID Anda, yaitu nilai variabel lingkungan ${PROJECT_ID} yang dijelaskan sebelumnya. Perhatikan bahwa example-grpc-server di subjectAltNames adalah nama akun layanan Kubernetes yang digunakan untuk Pod server gRPC dalam spesifikasi deployment.
```
if [ -z "$PROJECT_ID" ] ; then echo Please make sure PROJECT_ID is set. ; fi
cat << EOF > client-security-settings.yaml
securitySettings:
  clientTlsPolicy: projects/${PROJECT_ID}/locations/global/clientTlsPolicies/client-mtls-policy
  subjectAltNames:
    - "spiffe://${PROJECT_ID}.svc.id.goog/ns/default/sa/example-grpc-server"
EOF
```

Tambahkan pesan securitySettings ke layanan backend yang sudah Anda buat. Langkah-langkah ini mengekspor konten layanan backend saat ini, menambahkan pesan klien securitySetting, dan mengimpor kembali konten baru untuk memperbarui layanan backend.

gcloud compute backend-services export grpc-gke-helloworld-service --global \
  --destination=/tmp/grpc-gke-helloworld-service.yaml

cat /tmp/grpc-gke-helloworld-service.yaml client-security-settings.yaml \
  >/tmp/grpc-gke-helloworld-service1.yaml

gcloud compute backend-services import grpc-gke-helloworld-service --global \
  --source=/tmp/grpc-gke-helloworld-service1.yaml -q

Memverifikasi konfigurasi

Konfigurasi Cloud Service Mesh kini telah selesai, termasuk keamanan sisi server dan sisi klien. Selanjutnya, Anda menyiapkan dan menjalankan workload server dan klien. Contoh ini telah selesai.

Membuat klien gRPC tanpa proxy

Langkah ini mirip dengan langkah sebelumnya, Membuat layanan gRPC tanpa proxy. Anda menggunakan klien helloworld yang mendukung xDS dari direktori contoh xDS di repositori grpc-java. Anda membangun dan menjalankan klien dalam container yang dibangun dari image openjdk:8-jdk. Spesifikasi Kubernetes klien gRPC melakukan hal berikut.

Tindakan ini akan membuat akun layanan Kubernetes example-grpc-client yang digunakan oleh Pod klien gRPC.
${PROJNUM} mewakili nomor project Anda dan harus diganti dengan nomor yang sebenarnya.

Tambahkan anotasi berikut ke spesifikasi Pod Anda:

  annotations:
    security.cloud.google.com/use-workload-certificates: ""

Saat pembuatan, setiap Pod mendapatkan volume di /var/run/secrets/workload-spiffe-credentials. Volume ini berisi hal berikut:

private_key.pem adalah kunci pribadi yang dibuat secara otomatis.
certificates.pem adalah kumpulan sertifikat berformat PEM yang dapat ditampilkan ke Pod lain sebagai rantai sertifikat klien, atau digunakan sebagai rantai sertifikat server.
ca_certificates.pem adalah kumpulan sertifikat berformat PEM yang akan digunakan sebagai anchor kepercayaan saat memvalidasi rantai sertifikat klien yang ditampilkan oleh Pod lain, atau rantai sertifikat server yang diterima saat terhubung ke Pod lain.

Perhatikan bahwa ca_certificates.pem berisi sertifikat root untuk domain tepercaya lokal bagi beban kerja, yaitu kumpulan beban kerja cluster.

Sertifikat leaf di certificates.pem berisi pernyataan identitas SPIFFE teks biasa berikut:

spiffe://WORKLOAD_POOL/ns/NAMESPACE/sa/KUBERNETES_SERVICE_ACCOUNT

Dalam pernyataan ini:

WORKLOAD_POOL adalah nama kumpulan workload cluster.
NAMESPACE adalah nama akun layanan Kubernetes Anda.
KUBERNETES_SERVICE_ACCOUNT adalah namespace akun layanan Kubernetes Anda.

Petunjuk berikut untuk bahasa Anda membuat spesifikasi yang akan digunakan dalam contoh ini.

Java

Jalankan perintah berikut untuk memastikan nomor project ditetapkan dengan benar:

if [ -z "$PROJNUM" ] ; then export PROJNUM=$(gcloud projects describe $(gcloud info --format='value(config.project)') --format="value(projectNumber)") ; fi ; echo $PROJNUM

Buat spesifikasi berikut:

cat << EOF > example-grpc-client.yaml
apiVersion: v1
kind: ServiceAccount
metadata:
  name: example-grpc-client
  namespace: default
  annotations:
    iam.gke.io/gcp-service-account: ${PROJNUM}-compute@developer.gserviceaccount.com
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: example-grpc-client
  namespace: default
  labels:
    k8s-app: example-grpc-client
spec:
  replicas: 1
  selector:
    matchLabels:
      k8s-app: example-grpc-client
  strategy: {}
  template:
    metadata:
      annotations:
        security.cloud.google.com/use-workload-certificates: ""
      labels:
        k8s-app: example-grpc-client
    spec:
      containers:
      - image: openjdk:8-jdk
        imagePullPolicy: IfNotPresent
        name: example-grpc-client
        command:
        - /bin/sleep
        - inf
        env:
        - name: GRPC_XDS_BOOTSTRAP
          value: "/tmp/grpc-xds/td-grpc-bootstrap.json"
        resources:
          limits:
            cpu: 800m
            memory: 512Mi
          requests:
            cpu: 100m
            memory: 512Mi
        volumeMounts:
        - name: grpc-td-conf
          mountPath: /tmp/grpc-xds/
      initContainers:
      - name: grpc-td-init
        image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.16.0
        imagePullPolicy: Always
        args:
        - --config-mesh-experimental
        - "grpc-mesh"
        - --output
        - "/tmp/bootstrap/td-grpc-bootstrap.json"
        resources:
          limits:
            cpu: 100m
            memory: 100Mi
          requests:
            cpu: 10m
            memory: 100Mi
        volumeMounts:
        - name: grpc-td-conf
          mountPath: /tmp/bootstrap/
      serviceAccountName: example-grpc-client
      volumes:
      - name: grpc-td-conf
        emptyDir:
          medium: Memory
EOF

C++

Jalankan perintah berikut untuk memastikan nomor project ditetapkan dengan benar:

if [ -z "$PROJNUM" ] ; then export PROJNUM=$(gcloud projects describe $(gcloud info --format='value(config.project)') --format="value(projectNumber)") ; fi ; echo $PROJNUM

Buat spesifikasi berikut:

cat << EOF > example-grpc-client.yaml
apiVersion: v1
kind: ServiceAccount
metadata:
  name: example-grpc-client
  namespace: default
  annotations:
    iam.gke.io/gcp-service-account: ${PROJNUM}-compute@developer.gserviceaccount.com
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: example-grpc-client
  namespace: default
  labels:
    k8s-app: example-grpc-client
spec:
  replicas: 1
  selector:
    matchLabels:
      k8s-app: example-grpc-client
  strategy: {}
  template:
    metadata:
      annotations:
        security.cloud.google.com/use-workload-certificates: ""
      labels:
        k8s-app: example-grpc-client
    spec:
      containers:
      - image: phusion/baseimage:18.04-1.0.0
        imagePullPolicy: IfNotPresent
        name: example-grpc-client
        command:
        - /bin/sleep
        - inf
        env:
        - name: GRPC_XDS_BOOTSTRAP
          value: "/tmp/grpc-xds/td-grpc-bootstrap.json"
        resources:
          limits:
            cpu: 8
            memory: 8Gi
          requests:
            cpu: 300m
            memory: 512Mi
        volumeMounts:
        - name: grpc-td-conf
          mountPath: /tmp/grpc-xds/
      initContainers:
      - name: grpc-td-init
        image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.16.0
        imagePullPolicy: Always
        args:
        - --config-mesh-experimental
        - "grpc-mesh"
        - --output
        - "/tmp/bootstrap/td-grpc-bootstrap.json"
        resources:
          limits:
            cpu: 100m
            memory: 100Mi
          requests:
            cpu: 10m
            memory: 100Mi
        volumeMounts:
        - name: grpc-td-conf
          mountPath: /tmp/bootstrap/
      serviceAccountName: example-grpc-client
      volumes:
      - name: grpc-td-conf
        emptyDir:
          medium: Memory
EOF

Python

Jalankan perintah berikut untuk memastikan nomor project telah disetel dengan benar:

if [ -z "$PROJNUM" ] ; then export PROJNUM=$(gcloud projects describe $(gcloud info --format='value(config.project)') --format="value(projectNumber)") ; fi ; echo $PROJNUM

Buat spesifikasi berikut:

cat << EOF > example-grpc-client.yaml
apiVersion: v1
kind: ServiceAccount
metadata:
  name: example-grpc-client
  namespace: default
  annotations:
    iam.gke.io/gcp-service-account: ${PROJNUM}-compute@developer.gserviceaccount.com
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: example-grpc-client
  namespace: default
  labels:
    k8s-app: example-grpc-client
spec:
  replicas: 1
  selector:
    matchLabels:
      k8s-app: example-grpc-client
  strategy: {}
  template:
    metadata:
      annotations:
        security.cloud.google.com/use-workload-certificates: ""
      labels:
        k8s-app: example-grpc-client
    spec:
      containers:
      - image: phusion/baseimage:18.04-1.0.0
        imagePullPolicy: IfNotPresent
        name: example-grpc-client
        command:
        - /bin/sleep
        - inf
        env:
        - name: GRPC_XDS_BOOTSTRAP
          value: "/tmp/grpc-xds/td-grpc-bootstrap.json"
        resources:
          limits:
            cpu: 8
            memory: 8Gi
          requests:
            cpu: 300m
            memory: 512Mi
        volumeMounts:
        - name: grpc-td-conf
          mountPath: /tmp/grpc-xds/
      initContainers:
      - name: grpc-td-init
        image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.16.0
        imagePullPolicy: Always
        args:
        - --config-mesh-experimental
        - "grpc-mesh"
        - --output
        - "/tmp/bootstrap/td-grpc-bootstrap.json"
        resources:
          limits:
            cpu: 100m
            memory: 100Mi
          requests:
            cpu: 10m
            memory: 100Mi
        volumeMounts:
        - name: grpc-td-conf
          mountPath: /tmp/bootstrap/
      serviceAccountName: example-grpc-client
      volumes:
      - name: grpc-td-conf
        emptyDir:
          medium: Memory
EOF

Go

Jalankan perintah berikut untuk memastikan nomor project telah disetel dengan benar:

if [ -z "$PROJNUM" ] ; then export PROJNUM=$(gcloud projects describe $(gcloud info --format='value(config.project)') --format="value(projectNumber)") ; fi ; echo $PROJNUM

Buat spesifikasi berikut:

cat << EOF > example-grpc-client.yaml
apiVersion: v1
kind: ServiceAccount
metadata:
  name: example-grpc-client
  namespace: default
  annotations:
    iam.gke.io/gcp-service-account: ${PROJNUM}-compute@developer.gserviceaccount.com
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: example-grpc-client
  namespace: default
  labels:
    k8s-app: example-grpc-client
spec:
  replicas: 1
  selector:
    matchLabels:
      k8s-app: example-grpc-client
  strategy: {}
  template:
    metadata:
      annotations:
        security.cloud.google.com/use-workload-certificates: ""
      labels:
        k8s-app: example-grpc-client
    spec:
      containers:
      - image: golang:1.16-alpine
        imagePullPolicy: IfNotPresent
        name: example-grpc-client
        command:
        - /bin/sleep
        - inf
        env:
        - name: GRPC_XDS_BOOTSTRAP
          value: "/tmp/grpc-xds/td-grpc-bootstrap.json"
        resources:
          limits:
            cpu: 8
            memory: 8Gi
          requests:
            cpu: 300m
            memory: 512Mi
        volumeMounts:
        - name: grpc-td-conf
          mountPath: /tmp/grpc-xds/
      initContainers:
      - name: grpc-td-init
        image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.16.0
        imagePullPolicy: Always
        args:
        - --config-mesh-experimental
        - "grpc-mesh"
        - --output
        - "/tmp/bootstrap/td-grpc-bootstrap.json"
        resources:
          limits:
            cpu: 100m
            memory: 100Mi
          requests:
            cpu: 10m
            memory: 100Mi
        volumeMounts:
        - name: grpc-td-conf
          mountPath: /tmp/bootstrap/
      serviceAccountName: example-grpc-client
      volumes:
      - name: grpc-td-conf
        emptyDir:
          medium: Memory
EOF

Selesaikan prosesnya sebagai berikut.

Terapkan spesifikasi:

kubectl apply -f example-grpc-client.yaml

Berikan peran yang diperlukan ke akun layanan:

gcloud iam service-accounts add-iam-policy-binding \
  --role roles/iam.workloadIdentityUser \
  --member "serviceAccount:${PROJECT_ID}.svc.id.goog[default/example-grpc-client]" \
  ${PROJNUM}-compute@developer.gserviceaccount.com

gcloud projects add-iam-policy-binding ${PROJECT_ID} \
  --member "serviceAccount:${PROJECT_ID}.svc.id.goog[default/example-grpc-client]" \
  --role roles/trafficdirector.client

Verifikasi bahwa Pod klien sedang berjalan:

kubectl get pods

Perintah ini menampilkan teks yang mirip dengan berikut ini:

NAMESPACE   NAME                                    READY   STATUS    RESTARTS   AGE
default     example-grpc-client-7c969bb997-9fzjv    1/1     Running   0          104s
[..skip..]

Menjalankan server

Bangun dan jalankan server helloworld yang mendukung xDS di Pod server yang Anda buat sebelumnya.

Java

Dapatkan nama Pod yang dibuat untuk layanan example-grpc-server:

kubectl get pods | grep example-grpc-server

Anda akan melihat masukan seperti berikut:

default    example-grpc-server-77548868d-l9hmf     1/1    Running   0     105s

Buka shell ke Pod server:

kubectl exec -it example-grpc-server-77548868d-l9hmf -- /bin/bash

Di shell, pastikan file bootstrap di /tmp/grpc-xds/td-grpc-bootstrap.json cocok dengan skema yang dijelaskan di bagian File bootstrap.

Download gRPC Java versi 1.42.1 dan bangun aplikasi server xds-hello-world.

curl -L https://github.com/grpc/grpc-java/archive/v1.42.1.tar.gz | tar -xz

cd grpc-java-1.42.1/examples/example-xds

../gradlew --no-daemon installDist

Jalankan server dengan tanda --xds-creds untuk menunjukkan keamanan yang mendukung xDS, menggunakan 50051 sebagai port pendengar, dan xds-server sebagai nama identifikasi server:
```
./build/install/example-xds/bin/xds-hello-world-server --xds-creds 50051 xds-server
```
Setelah server mendapatkan konfigurasi yang diperlukan dari Cloud Service Mesh, Anda akan melihat output berikut:
```
Listening on port 50051
plain text health service listening on port 50052
```

C++

Dapatkan nama Pod yang dibuat untuk layanan example-grpc-server:

kubectl get pods | grep example-grpc-server

Anda akan melihat masukan seperti berikut:

default    example-grpc-server-77548868d-l9hmf     1/1    Running   0     105s

Buka shell ke Pod server:

kubectl exec -it example-grpc-server-77548868d-l9hmf -- /bin/bash

Di shell, pastikan file bootstrap di /tmp/grpc-xds/td-grpc-bootstrap.json cocok dengan skema yang dijelaskan di bagian File bootstrap.

Download gRPC C++ dan bangun aplikasi server xds-hello-world.

apt-get update -y && \
        apt-get install -y \
            build-essential \
            clang \
            python3 \
            python3-dev

curl -L https://github.com/grpc/grpc/archive/master.tar.gz | tar -xz

cd grpc-master

tools/bazel build examples/cpp/helloworld:xds_greeter_server

Jalankan server menggunakan 50051 sebagai port pendengar, dan xds_greeter_server sebagai nama identifikasi server:
```
bazel-bin/examples/cpp/helloworld/xds_greeter_server --port=50051 --maintenance_port=50052 --secure
```
Untuk menjalankan server tanpa kredensial, Anda dapat menentukan hal berikut:
```
bazel-bin/examples/cpp/helloworld/xds_greeter_server --nosecure
```
Setelah server mendapatkan konfigurasi yang diperlukan dari Cloud Service Mesh, Anda akan melihat output berikut:
```
Listening on port 50051
plain text health service listening on port 50052
```

Python

Dapatkan nama Pod yang dibuat untuk layanan example-grpc-server:

kubectl get pods | grep example-grpc-server

Anda akan melihat masukan seperti berikut:

default    example-grpc-server-77548868d-l9hmf     1/1    Running   0     105s

Buka shell ke Pod server:

kubectl exec -it example-grpc-server-77548868d-l9hmf -- /bin/bash

Di shell, pastikan file bootstrap di /tmp/grpc-xds/td-grpc-bootstrap.json cocok dengan skema yang dijelaskan di bagian File bootstrap.

Download gRPC Python versi 1.41.0 dan bangun aplikasi contoh.

apt-get update -y

apt-get install -y python3 python3-pip

curl -L https://github.com/grpc/grpc/archive/v1.41.x.tar.gz | tar -xz

cd grpc-1.41.x/examples/python/xds/

python3 -m virtualenv venv

source venv/bin/activate

python3 -m pip install -r requirements.txt

Jalankan server dengan tanda --xds-creds untuk menunjukkan keamanan yang mendukung xDS, menggunakan 50051 sebagai port pendengar.
```
python3 server.py 50051 --xds-creds
```

Setelah server mendapatkan konfigurasi yang diperlukan dari Cloud Service Mesh, Anda akan melihat output berikut:

2021-05-06 16:10:34,042: INFO     Running with xDS Server credentials
2021-05-06 16:10:34,043: INFO     Greeter server listening on port 50051
2021-05-06 16:10:34,046: INFO     Maintenance server listening on port 50052

Go

Dapatkan nama Pod yang dibuat untuk layanan example-grpc-server:

kubectl get pods | grep example-grpc-server

Anda akan melihat masukan seperti berikut:

default    example-grpc-server-77548868d-l9hmf     1/1    Running   0     105s

Buka shell ke Pod server:

kubectl exec -it example-grpc-server-77548868d-l9hmf -- /bin/sh

Di shell, pastikan file bootstrap di /tmp/grpc-xds/td-grpc-bootstrap.json cocok dengan skema yang dijelaskan di bagian File bootstrap.

Download gRPC Go versi 1.41.0 dan buka direktori yang berisi aplikasi server xds-hello-world.

apk add curl

curl -L https://github.com/grpc/grpc-go/archive/v1.42.0.tar.gz | tar -xz

cd grpc-go-1.42.0/examples/features/xds/server

Bangun dan jalankan server dengan tanda --xds_creds untuk menunjukkan keamanan yang mendukung xDS, menggunakan 50051 sebagai port pendengar:
```
GRPC_GO_LOG_VERBOSITY_LEVEL=2 GRPC_GO_LOG_SEVERITY_LEVEL="info" \
  go run main.go \
  -xds_creds \
  -port 50051
```
Setelah server mendapatkan konfigurasi yang diperlukan dari Cloud Service Mesh, Anda akan melihat output berikut:
```
Using xDS credentials...
Serving GreeterService on 0.0.0.0:50051 and HealthService on 0.0.0.0:50052
```

Proses pemeriksaan kondisi memerlukan waktu 3 hingga 5 menit untuk menunjukkan bahwa layanan Anda dalam kondisi baik setelah server dimulai.

Jalankan klien dan verifikasi konfigurasi

Bangun dan jalankan klien helloworld yang mendukung xDS di Pod klien yang Anda buat sebelumnya.

Java

Dapatkan nama Pod klien:

kubectl get pods | grep example-grpc-client

Anda akan melihat masukan seperti ini:

default    example-grpc-client-7c969bb997-9fzjv     1/1    Running   0     105s

Buka shell ke Pod klien:

kubectl exec -it example-grpc-client-7c969bb997-9fzjv -- /bin/bash

Di shell perintah, download gRPC Java versi 1.42.1 dan bangun aplikasi klien xds-hello-world.

curl -L https://github.com/grpc/grpc-java/archive/v1.42.1.tar.gz | tar -xz

cd grpc-java-1.42.1/examples/example-xds

../gradlew --no-daemon installDist

Jalankan klien dengan tanda --xds-creds untuk menunjukkan keamanan yang mendukung xDS, nama klien, dan string koneksi target:
```
./build/install/example-xds/bin/xds-hello-world-client --xds-creds xds-client \
      xds:///helloworld-gke:8000
```
Anda akan melihat output yang serupa dengan ini:
```
Greeting: Hello xds-client, from xds-server
```

C++

Dapatkan nama Pod klien:

kubectl get pods | grep example-grpc-client

Anda akan melihat masukan seperti ini:

default    example-grpc-client-7c969bb997-9fzjv     1/1    Running   0     105s

Buka shell ke Pod klien:

kubectl exec -it example-grpc-client-7c969bb997-9fzjv -- /bin/bash

Setelah berada di dalam shell, download gRPC C++ dan bangun aplikasi klien xds-hello-world.

apt-get update -y && \
        apt-get install -y \
            build-essential \
            clang \
            python3 \
            python3-dev

curl -L https://github.com/grpc/grpc/archive/master.tar.gz | tar -xz

cd grpc-master

tools/bazel build examples/cpp/helloworld:xds_greeter_client

Jalankan klien dengan tanda --xds-creds untuk menunjukkan keamanan yang mendukung xDS, nama klien, dan string koneksi target:
```
bazel-bin/examples/cpp/helloworld/xds_greeter_client --target=xds:///helloworld-gke:8000
```
Untuk menjalankan klien tanpa kredensial, gunakan perintah berikut:
```
bazel-bin/examples/cpp/helloworld/xds_greeter_client --target=xds:///helloworld-gke:8000 --nosecure
```
Anda akan melihat output yang serupa dengan ini:
```
Greeter received: Hello world
```

Python

Dapatkan nama Pod klien:

kubectl get pods | grep example-grpc-client

Anda akan melihat masukan seperti ini:

default    example-grpc-client-7c969bb997-9fzjv     1/1    Running   0     105s

Buka shell ke Pod klien:

kubectl exec -it example-grpc-client-7c969bb997-9fzjv -- /bin/bash

Setelah berada di dalam shell, download gRPC Python versi 1.41.0 dan buat aplikasi klien contoh.

apt-get update -y
apt-get install -y python3 python3-pip
python3 -m pip install virtualenv
curl -L https://github.com/grpc/grpc/archive/v1.41.x.tar.gz | tar -xz
cd grpc-1.41.x/examples/python/xds/
python3 -m virtualenv venv
source venv/bin/activate
python3 -m pip install -r requirements.txt

Jalankan klien dengan tanda --xds-creds untuk menunjukkan keamanan yang mendukung xDS, nama klien, dan string koneksi target:
```
python3 client.py xds:///helloworld-gke:8000 --xds-creds
```
Anda akan melihat output yang serupa dengan ini:
```
Greeter client received: Hello you from example-host!
```

Go

Dapatkan nama Pod klien:

kubectl get pods | grep example-grpc-client

Anda akan melihat masukan seperti ini:

default    example-grpc-client-7c969bb997-9fzjv     1/1    Running   0     105s

Buka shell ke Pod klien:

kubectl exec -it example-grpc-client-7c969bb997-9fzjv -- /bin/sh

Setelah berada di dalam shell, download gRPC Go versi 1.42.0 dan buka direktori yang berisi aplikasi klien xds-hello-world.

apk add curl

curl -L https://github.com/grpc/grpc-go/archive/v1.42.0.tar.gz | tar -xz

cd grpc-go-1.42.0/examples/features/xds/client

Buat dan jalankan klien dengan tanda --xds_creds untuk menunjukkan keamanan yang mendukung xDS, nama klien, dan string koneksi target:

GRPC_GO_LOG_VERBOSITY_LEVEL=2 GRPC_GO_LOG_SEVERITY_LEVEL="info" \
  go run main.go \
  -xds_creds \
  -name xds-client \
  -target xds:///helloworld-gke:8000

Anda akan melihat output yang serupa dengan ini:

Greeting: Hello xds-client, from example-grpc-server-77548868d-l9hmf

Mengonfigurasi akses tingkat layanan dengan kebijakan otorisasi

Dukungan gRFC A41 diperlukan untuk dukungan kebijakan otorisasi. Anda dapat menemukan versi bahasa yang diperlukan di github

Gunakan petunjuk ini untuk mengonfigurasi akses tingkat layanan dengan kebijakan otorisasi. Sebelum membuat kebijakan otorisasi, baca peringatan di Membatasi akses menggunakan otorisasi.

Untuk mempermudah verifikasi konfigurasi, buat nama host tambahan yang dapat digunakan klien untuk merujuk ke layanan helloworld-gke.

Perbarui spesifikasi GRPCRoute yang sebelumnya disimpan di grpc_route.yaml

name: helloworld-grpc-route
hostnames:
- helloworld-gke:8000
- helloworld-gke-noaccess:8000
meshes:
- projects/PROJECT_NUMBER/locations/global/meshes/grpc-mesh
rules:
- action:
    destinations:
    - serviceName: projects/PROJECT_NUMBER/locations/global/backendServices/grpc-gke-helloworld-service

Impor lagi resource GRPCRoute dari spesifikasi grpc_route.yaml.

gcloud network-services grpc-routes import helloworld-grpc-route \
  --source=grpc_route.yaml \
  --location=global

Petunjuk berikut membuat kebijakan otorisasi yang mengizinkan permintaan yang dikirim oleh akun example-grpc-client yang nama hostnya adalah helloworld-gke:8000 dan portnya adalah 50051.

gcloud

Buat kebijakan otorisasi dengan membuat file bernama helloworld-gke-authz-policy.yaml.

action: ALLOW
name: helloworld-gke-authz-policy
rules:
- sources:
  - principals:
    - spiffe://PROJECT_ID.svc.id.goog/ns/default/sa/example-grpc-client
  destinations:
  - hosts:
    - helloworld-gke:8000
    ports:
    - 50051

Impor kebijakan.

gcloud network-security authorization-policies import \
  helloworld-gke-authz-policy \
  --source=helloworld-gke-authz-policy.yaml \
  --location=global

Perbarui kebijakan endpoint untuk mereferensikan kebijakan otorisasi baru dengan menambahkan berikut ini ke file ep-mtls-psms.yaml.
```
authorizationPolicy: projects/${PROJECT_ID}/locations/global/authorizationPolicies/helloworld-gke-authz-policy
```
Kebijakan endpoint kini menentukan bahwa mTLS dan kebijakan otorisasi harus diterapkan pada permintaan masuk ke Pod yang file bootstrap gRPC-nya berisi label app:helloworld.

Impor kebijakan:

gcloud network-services endpoint-policies import ep-mtls-psms \
  --source=ep-mtls-psms.yaml --location=global

Memvalidasi kebijakan otorisasi

Gunakan petunjuk ini untuk mengonfirmasi bahwa kebijakan otorisasi berfungsi dengan benar.

Java

Buka shell ke pod klien yang Anda gunakan sebelumnya.

kubectl exec -it example-grpc-client-7c969bb997-9fzjv -- /bin/bash

Di command shell, jalankan perintah berikut untuk memvalidasi penyiapan.

cd grpc-java-1.42.1/examples/example-xds
./build/install/example-xds/bin/xds-hello-world-client --xds-creds xds-client \
      xds:///helloworld-gke:8000

Anda akan melihat output yang serupa dengan ini:

Greeting: Hello xds-client, from xds-server

Jalankan klien lagi dengan nama server alternatif. Perhatikan bahwa ini adalah kasus kegagalan. Permintaan tidak valid karena kebijakan otorisasi hanya mengizinkan akses ke nama host helloworld-gke:8000.
```
./build/install/example-xds/bin/xds-hello-world-client --xds-creds xds-client \
      xds:///helloworld-gke-noaccess:8000
```
Anda akan melihat output yang serupa dengan ini:
```
WARNING: RPC failed: Status{code=PERMISSION_DENIED}
```
Jika Anda tidak melihat output ini, kebijakan otorisasi mungkin belum digunakan. Tunggu beberapa menit, lalu coba lagi seluruh proses verifikasi.

Go

Buka shell ke pod klien yang Anda gunakan sebelumnya.

kubectl exec -it example-grpc-client-7c969bb997-9fzjv -- /bin/bash

Di command shell, jalankan perintah berikut untuk memvalidasi penyiapan.

cd grpc-go-1.42.0/examples/features/xds/client
GRPC_GO_LOG_VERBOSITY_LEVEL=2 GRPC_GO_LOG_SEVERITY_LEVEL="info" \
  go run main.go \
  -xds_creds \
  -name xds-client \
  -target xds:///helloworld-gke:8000

Anda akan melihat output yang serupa dengan ini:

Greeting: Hello xds-client, from example-grpc-server-77548868d-l9hmf

Jalankan klien lagi dengan nama server alternatif. Perhatikan bahwa ini adalah kasus kegagalan. Permintaan tidak valid karena kebijakan otorisasi hanya mengizinkan akses ke nama host helloworld-gke:8000.
```
GRPC_GO_LOG_VERBOSITY_LEVEL=2 GRPC_GO_LOG_SEVERITY_LEVEL="info" \
  go run main.go \
  -xds_creds \
  -name xds-client \
  -target xds:///helloworld-gke-noaccess:8000
```
Anda akan melihat output yang serupa dengan ini:
```
could not greet: rpc error: code = PermissionDenied desc = Incoming RPC is not allowed: rpc error: code = PermissionDenied desc = incoming RPC did not match an allow policy
exit status 1
```
Jika Anda tidak melihat output ini, kebijakan otorisasi mungkin belum digunakan. Tunggu beberapa menit, lalu coba lagi seluruh proses verifikasi.

Menggunakan TLS, bukan mTLS

Penggunaan TLS dalam contoh ini hanya memerlukan sedikit perubahan.

Di ServerTlsPolicy, lepaskan mtlsPolicy:

cat << EOF > server-tls-policy.yaml
name: "server-tls-policy"
serverCertificate:
  certificateProviderInstance:
    pluginInstance: google_cloud_private_spiffe
EOF

Gunakan kebijakan ini di EndpointPolicy sebagai gantinya:

cat << EOF > ep-tls-psms.yaml
name: "ep-mtls-psms"
type: "GRPC_SERVER"
serverTlsPolicy: "projects/${PROJECT_ID}/locations/global/serverTlsPolicies/server-tls-policy"
trafficPortSelector:
  ports:
  - "50051"
endpointMatcher:
  metadataLabelMatcher:
    metadataLabelMatchCriteria: "MATCH_ALL"
    metadataLabels: []
EOF

ClientTlsPolicy untuk mTLS juga berfungsi dalam kasus TLS, tetapi bagian clientCertificate dari kebijakan dapat dihilangkan karena tidak diperlukan untuk TLS:

cat << EOF > client-tls-policy.yaml
name: "client-tls-policy"
serverValidationCa:
- certificateProviderInstance:
    pluginInstance: google_cloud_private_spiffe
EOF

Menggunakan keamanan layanan dengan contoh Wallet

Bagian ini memberikan ringkasan tingkat tinggi tentang cara mengaktifkan contoh Wallet dengan keamanan layanan, untuk Java, C++, dan Go.

Java

Anda dapat menemukan kode sumber contoh untuk Java di github. Kode ini sudah menggunakan kredensial XdsChannel danXdsServer saat Anda mengonfigurasi keamanan tanpa proxy.

Petunjuk ini menjelaskan cara mengonfigurasi contoh Wallet dengan Go. Prosesnya mirip untuk Java. Petunjuk ini menggunakan image Docker yang sudah ada yang Anda dapatkan dari repositori penampung.Google Cloud

Untuk membuat contoh, ikuti petunjuk berikut:

Clone repositori dan dapatkan file di direktori gRPC examples.
Edit file 00-common-env.sh. Beri komentar pada baris yang ada yang menetapkan nilai WALLET_DOCKER_IMAGE ke image Docker Go dan hapus komentar pada baris yang menetapkan nilai WALLET_DOCKER_IMAGE ke image Docker Java.
Buat dan konfigurasi instance Cloud Router, menggunakan petunjuk di Membuat dan mengonfigurasi instance Cloud Router atau menggunakan fungsi create_cloud_router_instances dalam skrip 10.apis.sh.
Buat cluster menggunakan petunjuk untuk contoh hello world. atau fungsi create_cluster dalam skrip 20-cluster.sh.
Buat certificate authority pribadi menggunakan petunjuk untuk CA Service atau menggunakan skrip 30-private-ca-setup.sh.
Buat resource Kubernetes, termasuk akun layanan, namespace, layanan Kubernetes, NEG, dan deployment sisi server untuk semua layanan: account, stats, stats_premium, wallet_v1, wallet_v2, menggunakan skrip 40-k8s-resources.sh.
Untuk setiap layanan yang Anda buat, buat health check dan layanan backend menggunakan create_health_check dan create_backend_service dalam skrip 50-td-components.sh.
Buat komponen perutean Cloud Service Mesh menggunakan create_routing_components dalam skrip 60-routing-components.sh.
Buat komponen keamanan Cloud Service Mesh untuk setiap layanan backend menggunakan create_security_components dalam skrip 70-security-components.sh.
Buat deployment klien Wallet menggunakan create_client_deployment dalam skrip 75-client-deployment.sh.
Verifikasi konfigurasi dengan meluncurkan klien seperti yang dijelaskan dalam Verifikasi dengan klien grpc-wallet.

C++

Anda dapat menemukan kode sumber contoh untuk C++ di github. Kode ini sudah menggunakan kredensial XdsChannel danXdsServer saat Anda mengonfigurasi keamanan tanpa proxy.

Petunjuk ini menjelaskan cara mengonfigurasi contoh Wallet dengan Go. Prosesnya serupa untuk C++. Petunjuk ini menggunakan image Docker yang sudah ada yang Anda dapatkan dari Google Cloud repositori penampung.

Untuk membuat contoh, ikuti petunjuk berikut:

Clone repositori dan dapatkan file di direktori gRPC examples.
Edit file 00-common-env.sh. Beri komentar pada baris yang ada yang menetapkan nilai WALLET_DOCKER_IMAGE ke image Docker Go dan hapus komentar pada baris yang menetapkan nilai WALLET_DOCKER_IMAGE ke image Docker C++.
Buat dan konfigurasi instance Cloud Router, menggunakan petunjuk di Membuat dan mengonfigurasi instance Cloud Router atau menggunakan fungsi create_cloud_router_instances dalam skrip 10.apis.sh.
Buat cluster menggunakan petunjuk untuk contoh hello world. atau fungsi create_cluster dalam skrip 20-cluster.sh.
Buat certificate authority pribadi menggunakan petunjuk untuk CA Service atau menggunakan skrip 30-private-ca-setup.sh.
Buat resource Kubernetes, termasuk akun layanan, namespace, layanan Kubernetes, NEG, dan deployment sisi server untuk semua layanan: account, stats, stats_premium, wallet_v1, wallet_v2, menggunakan skrip 40-k8s-resources.sh.
Untuk setiap layanan yang Anda buat, buat health check dan layanan backend menggunakan create_health_check dan create_backend_service dalam skrip 50-td-components.sh.
Buat komponen perutean Cloud Service Mesh menggunakan create_routing_components dalam skrip 60-routing-components.sh.
Buat komponen keamanan Cloud Service Mesh untuk setiap layanan backend menggunakan create_security_components dalam skrip 70-security-components.sh.
Buat deployment klien Wallet menggunakan create_client_deployment dalam skrip 75-client-deployment.sh.
Verifikasi konfigurasi dengan meluncurkan klien seperti yang dijelaskan dalam Verifikasi dengan klien grpc-wallet.

Go

Anda dapat menemukan contoh kode sumber untuk Go di github. Kode ini sudah menggunakan kredensial XdsChannel dan XdsServer saat Anda mengonfigurasi keamanan tanpa proxy.

Petunjuk ini menggunakan image Docker yang sudah ada yang Anda dapatkan dari Google Cloud repositori penampung.

Untuk membuat contoh, ikuti petunjuk berikut:

Clone repositori dan dapatkan file di direktori gRPC examples.
Edit file 00-common-env.sh untuk menetapkan nilai yang benar untuk variabel lingkungan.
Buat dan konfigurasi instance Cloud Router, menggunakan petunjuk di Membuat dan mengonfigurasi instance Cloud Router atau menggunakan fungsi create_cloud_router_instances dalam skrip 10.apis.sh.
Buat cluster menggunakan petunjuk untuk contoh hello world. atau fungsi create_cluster dalam skrip 20-cluster.sh.
Buat certificate authority pribadi menggunakan petunjuk untuk CA Service atau menggunakan skrip 30-private-ca-setup.sh.
Buat resource Kubernetes, termasuk akun layanan, namespace, layanan Kubernetes, NEG, dan deployment sisi server untuk semua layanan: account, stats, stats_premium, wallet_v1, wallet_v2, menggunakan skrip 40-k8s-resources.sh.
Untuk setiap layanan yang Anda buat, buat health check dan layanan backend menggunakan create_health_check dan create_backend_service dalam skrip 50-td-components.sh.
Buat komponen perutean Cloud Service Mesh menggunakan create_routing_components dalam skrip 60-routing-components.sh.
Buat komponen keamanan Cloud Service Mesh untuk setiap layanan backend menggunakan create_security_components dalam skrip 70-security-components.sh.
Buat deployment klien Wallet menggunakan create_client_deployment dalam skrip 75-client-deployment.sh.
Verifikasi konfigurasi dengan meluncurkan klien seperti yang dijelaskan dalam Verifikasi dengan klien grpc-wallet.

File bootstrap

Proses penyiapan dalam panduan ini menggunakan generator bootstrap untuk membuat file bootstrap yang diperlukan. Bagian ini memberikan informasi referensi tentang file bootstrap itu sendiri.

File bootstrap berisi informasi konfigurasi yang diperlukan oleh kode gRPC tanpa proxy, termasuk informasi koneksi untuk server xDS. File bootstrap berisi konfigurasi keamanan yang diperlukan oleh fitur keamanan gRPC tanpa proxy. Server gRPC memerlukan satu kolom tambahan. Contoh file bootstrap terlihat seperti ini:

{
  "xds_servers": [
    {
      "server_uri": "trafficdirector.googleapis.com:443",
      "channel_creds": [
        {
          "type": "google_default"
        }
      ],
      "server_features": [
        "xds_v3"
      ]
    }
  ],
  "authorities": {
    "traffic-director-c2p.xds.googleapis.com": {
      "xds_servers": [
        {
          "server_uri": "dns:///directpath-pa.googleapis.com",
          "channel_creds": [
            {
              "type": "google_default"
            }
          ],
          "server_features": [
            "xds_v3",
            "ignore_resource_deletion"
          ]
        }
      ],
      "client_listener_resource_name_template": "xdstp://traffic-director-c2p.xds.googleapis.com/envoy.config.listener.v3.Listener/%s"
    }
  },
  "node": {
    "id": "projects/9876012345/networks/mesh:grpc-mesh/nodes/b59f49cc-d95a-4462-9126-112f794d5dd3",
    "cluster": "cluster",
    "metadata": {
      "INSTANCE_IP": "10.28.2.8",
      "TRAFFICDIRECTOR_DIRECTPATH_C2P_IPV6_CAPABLE": true,
      "TRAFFICDIRECTOR_GCP_PROJECT_NUMBER": "223606568246",
      "TRAFFICDIRECTOR_NETWORK_NAME": "default",
      "app": "helloworld"
    },
    "locality": {
      "zone": "us-central1-c"
    }
  },
  "certificate_providers": {
    "google_cloud_private_spiffe": {
      "plugin_name": "file_watcher",
      "config": {
        "certificate_file": "/var/run/secrets/workload-spiffe-credentials/certificates.pem",
        "private_key_file": "/var/run/secrets/workload-spiffe-credentials/private_key.pem",
        "ca_certificate_file": "/var/run/secrets/workload-spiffe-credentials/ca_certificates.pem",
        "refresh_interval": "600s"
      }
    }
  },
  "server_listener_resource_name_template": "grpc/server?xds.resource.listening_address=%s"
}

Pembaruan pada file bootstrap untuk layanan keamanan

Kolom berikut mencerminkan modifikasi yang terkait dengan keamanan dan penggunaan xDS v3:

Kolom id di dalam node memberikan identitas unik untuk klien gRPC ke Cloud Service Mesh. Anda harus memberikan nomor project Google Cloud dan nama jaringan menggunakan ID node dalam format ini:

projects/{project number}/networks/{network name}/nodes/[UNIQUE_ID]

Contoh untuk project nomor 1234 dan jaringan default adalah:

projects/1234/networks/default/nodes/client1

Kolom INSTANCE_IP adalah alamat IP Pod, atau 0.0.0.0 untuk menunjukkan INADDR_ANY. Kolom ini digunakan oleh server gRPC untuk mengambil resource Listener dari Cloud Service Mesh untuk keamanan sisi server.

Kolom konfigurasi keamanan dalam file bootstrap

Kunci JSON	Jenis	Nilai	Catatan
`server_listener_resource_name_template`	String	`grpc/server?xds.resource.listening_address=%s`	Diperlukan untuk server gRPC. gRPC menggunakan nilai ini untuk menyusun nama resource guna mengambil resource `Listener` dari Cloud Service Mesh untuk keamanan sisi server dan konfigurasi lainnya. gRPC menggunakan nilai ini untuk membentuk string nama resource
`certificate_providers`	Struktur JSON	`google_cloud_private_spiffe`	Wajib. Nilainya adalah struct JSON yang merepresentasikan peta nama ke instance penyedia sertifikat. Instance penyedia sertifikat digunakan untuk mengambil identitas dan sertifikat root. File bootstrap contoh berisi satu nama: `google_cloud_private_spiffe` dengan struct JSON instance penyedia sertifikat sebagai nilai. Setiap struktur JSON instance penyedia sertifikat memiliki dua kolom: `plugin_name`. Nilai wajib yang mengidentifikasi plugin penyedia sertifikat yang akan digunakan sebagaimana diperlukan oleh arsitektur plugin gRPC untuk penyedia sertifikat. gRPC memiliki dukungan bawaan untuk plugin file-watcher yang digunakan dalam penyiapan ini. plugin_name adalah `file_watcher`. `config`. Nilai wajib yang mengidentifikasi blog konfigurasi JSON untuk plugin `file_watcher`. Skema dan konten bergantung pada plugin.

Isi struktur JSON config untuk plugin file_watcher adalah:

certificate_file: String wajib diisi. Nilai ini adalah lokasi sertifikat identitas.
private_key_file: String wajib diisi. Nilainya adalah lokasi file kunci pribadi, yang harus cocok dengan sertifikat identitas.
ca_certificate_file: String wajib diisi. Nilainya adalah lokasi sertifikat root, yang juga dikenal sebagai paket kepercayaan.
refresh_interval: String opsional. Nilai menunjukkan interval pengambilan data, yang ditentukan menggunakan representasi string pemetaan JSON Durasi. Nilai defaultnya adalah "600s", durasi 10 menit.

Generator bootstrap

Image container bootstrap generator tersedia di gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.16.0. Kode sumbernya tersedia di https://github.com/GoogleCloudPlatform/traffic-director-grpc-bootstrap. Opsi command line yang paling umum digunakan adalah:

--output: Gunakan opsi ini untuk menentukan tempat file bootstrap output ditulis, misalnya, perintah --output /tmp/bootstrap/td-grpc-bootstrap.json menghasilkan file bootstrap ke /tmp/bootstrap/td-grpc-bootstrap.json di sistem file Pod.
--config-mesh-experimental: Gunakan opsi ini untuk menentukan nama mesh, yang cocok dengan resource Mesh.
--node-metadata: Gunakan tanda ini untuk mengisi metadata node dalam file bootstrap. Hal ini diperlukan saat Anda menggunakan pencocok label metadata di EndpointPolicy tempat Cloud Service Mesh menggunakan data label yang disediakan di bagian metadata node pada file bootstrap. Argumen diberikan dalam bentuk key=value, misalnya: --node-metadata version=prod --node-metadata type=grpc

Informasi sebelumnya menambahkan hal berikut di bagian metadata node dari file bootstrap:

{
  "node": {
...
    "metadata": {
      "version": "prod",
      "type": "grpc",
...
    },
...
  },
...
}

Menghapus deployment

Secara opsional, Anda dapat menjalankan perintah ini untuk menghapus deployment yang Anda buat menggunakan panduan ini.

Untuk menghapus cluster, jalankan perintah ini:

gcloud container clusters delete CLUSTER_NAME --zone ZONE --quiet

Untuk menghapus resource yang Anda buat, jalankan perintah berikut:

gcloud compute backend-services delete grpc-gke-helloworld-service --global --quiet
gcloud compute network-endpoint-groups delete example-grpc-server --zone ZONE --quiet
gcloud compute firewall-rules delete grpc-gke-allow-health-checks --quiet
gcloud compute health-checks delete grpc-gke-helloworld-hc --quiet
gcloud network-services endpoint-policies delete ep-mtls-psms \
    --location=global --quiet
gcloud network-security authorization-policies delete helloworld-gke-authz-policy \
   --location=global --quiet
gcloud network-security client-tls-policies delete client-mtls-policy \
    --location=global --quiet
gcloud network-security server-tls-policies delete server-tls-policy \
    --location=global --quiet
gcloud network-security server-tls-policies delete server-mtls-policy \
    --location=global --quiet

Pemecahan masalah

Gunakan petunjuk ini untuk membantu Anda menyelesaikan masalah terkait deployment keamanan.

Workload tidak dapat mengambil konfigurasi dari Cloud Service Mesh

Jika Anda melihat error yang serupa dengan ini:

PERMISSION_DENIED: Request had insufficient authentication scopes.

Pastikan hal berikut:

Anda membuat cluster GKE dengan argumen --scopes=cloud-platform argument.
Anda menetapkan roles/trafficdirector.client ke akun layanan Kubernetes.
Anda menetapkan roles/trafficdirector.client ke akun layanan Google Cloud default Anda (${GSA_EMAIL} di atas).
Anda telah mengaktifkan layanan (API) trafficdirector.googleapis.com.

Server gRPC Anda tidak menggunakan TLS/mTLS meskipun dengan konfigurasi Cloud Service Mesh yang benar

Pastikan Anda menentukan GRPC_SERVER dalam konfigurasi kebijakan endpoint. Jika Anda menentukan SIDECAR_PROXY, gRPC akan mengabaikan konfigurasi.

Anda tidak dapat membuat cluster GKE dengan versi cluster yang diminta

Perintah pembuatan cluster GKE mungkin gagal dengan error seperti ini:

Node version "1.20.5-gke.2000" is unsupported.

Pastikan Anda menggunakan argumen --release-channel rapid dalam perintah pembuatan cluster. Anda harus menggunakan saluran rilis cepat untuk mendapatkan versi yang benar untuk rilis ini.

Anda melihat error `No usable endpoint`

Jika klien tidak dapat berkomunikasi dengan server karena error No usable endpoint, pemeriksa kondisi mungkin telah menandai backend server sebagai tidak sehat. Untuk memeriksa kondisi backend, jalankan perintah gcloud ini:

gcloud compute backend-services get-health grpc-gke-helloworld-service --global

Jika perintah menampilkan status backend tidak responsif, hal ini mungkin disebabkan oleh salah satu alasan berikut:

Firewall tidak dibuat atau tidak berisi rentang IP sumber yang benar.
Tag target di firewall Anda tidak cocok dengan tag di cluster yang Anda buat.

Workload tidak dapat berkomunikasi dalam penyiapan keamanan

Jika beban kerja Anda tidak dapat berkomunikasi setelah Anda menyiapkan keamanan untuk mesh layanan tanpa proxy, ikuti petunjuk ini untuk menentukan penyebabnya.

Nonaktifkan keamanan tanpa proxy dan hilangkan masalah dalam kasus penggunaan load balancing mesh layanan tanpa proxy. Untuk menonaktifkan keamanan di mesh, lakukan salah satu tindakan berikut:
1. Menggunakan kredensial teks biasa di sisi klien dan server ATAU
2. tidak mengonfigurasi keamanan untuk layanan backend dan kebijakan endpoint dalam konfigurasi Cloud Service Mesh.

Ikuti langkah-langkah di Memecahkan masalah deployment Cloud Service Mesh tanpa proxy, karena tidak ada penyiapan keamanan dalam deployment Anda.

Ubah beban kerja Anda untuk menggunakan kredensial xDS dengan kredensial teks biasa atau kredensial tidak aman sebagai kredensial penggantian. Pertahankan konfigurasi Cloud Service Mesh dengan keamanan dinonaktifkan seperti yang dibahas sebelumnya. Dalam hal ini, meskipun gRPC memungkinkan Cloud Service Mesh mengonfigurasi keamanan, Cloud Service Mesh tidak mengirimkan informasi keamanan sehingga gRPC harus melakukan penggantian ke kredensial teks biasa (atau tidak aman) yang akan berfungsi mirip dengan kasus pertama sebelumnya. Jika casing ini tidak berfungsi, lakukan hal berikut:
1. Tingkatkan tingkat logging di sisi klien dan server sehingga Anda dapat melihat pesan xDS yang dipertukarkan antara gRPC dan Cloud Service Mesh.
2. Pastikan Cloud Service Mesh tidak mengaktifkan keamanan dalam respons CDS dan LDS yang dikirim ke workload.
3. Pastikan bahwa beban kerja tidak menggunakan mode TLS atau mTLS di salurannya. Jika Anda melihat pesan log yang terkait dengan handshake TLS, periksa kode sumber aplikasi Anda dan pastikan Anda menggunakan teks biasa atau tidak aman sebagai kredensial pengganti. Jika kode sumber aplikasi sudah benar, mungkin ada bug di library gRPC
Pastikan integrasi Layanan CA dengan GKE berfungsi dengan benar untuk cluster GKE Anda dengan mengikuti langkah-langkah pemecahan masalah dalam Panduan Pengguna tersebut. Pastikan sertifikat dan kunci yang disediakan oleh fitur tersebut tersedia di direktori yang ditentukan, /var/run/secrets/workload-spiffe-credentials/.
Aktifkan TLS (bukan mTLS) di mesh Anda, seperti yang dijelaskan sebelumnya, lalu mulai ulang workload klien dan server Anda.
1. Tingkatkan tingkat logging di sisi klien dan server agar dapat melihat pesan xDS yang dipertukarkan antara gRPC dan Cloud Service Mesh.
2. Pastikan Cloud Service Mesh telah mengaktifkan keamanan dalam respons CDS dan LDS yang dikirim ke workload.

Klien gagal dengan `CertificateException` dan pesan `Peer certificate SAN check failed`

Hal ini menunjukkan adanya masalah pada nilai subjectAltNames dalam pesan SecuritySettings. Perhatikan bahwa nilai ini didasarkan pada layanan Kubernetes yang Anda buat untuk layanan backend Anda. Untuk setiap layanan Kubernetes yang Anda buat, ada ID SPIFFE terkait, dalam format ini:

spiffe://${WORKLOAD_POOL}/ns/${K8S_NAMESPACE}/sa/${SERVICE_ACCOUNT}

Nilai ini adalah:

WORKLOAD_POOL: Kumpulan workload untuk cluster, yaitu ${PROJECT_ID}.svc.id.goog
K8S_NAMESPACE: Namespace Kubernetes yang Anda gunakan dalam deployment layanan
SERVICE_ACCOUNT: Akun layanan Kubernetes yang Anda gunakan dalam deployment layanan

Untuk setiap layanan Kubernetes yang Anda lampirkan ke layanan backend sebagai grup endpoint jaringan, pastikan Anda menghitung SPIFFE ID dengan benar dan menambahkan SPIFFE ID tersebut ke kolom subjectAltNames dalam pesan SecuritySettings.

Aplikasi tidak dapat menggunakan sertifikat mTLS dengan library gRPC Anda

Jika aplikasi Anda tidak dapat menggunakan sertifikat mTLS dengan library gRPC, lakukan hal berikut:

Pastikan spesifikasi Pod berisi anotasi security.cloud.google.com/use-workload-certificates yang dijelaskan dalam Membuat layanan gRPC tanpa proxy dengan NEG.
Verifikasi bahwa file yang berisi rantai sertifikat beserta sertifikat leaf, kunci pribadi, dan sertifikat CA tepercaya dapat diakses di jalur berikut dari dalam Pod:
1. Rantai sertifikat beserta sertifikat entitas akhir: "/var/run/secrets/workload-spiffe-credentials/certificates.pem"
2. Kunci pribadi: "/var/run/secrets/workload-spiffe-credentials/private_key.pem"
3. Paket CA: "/var/run/secrets/workload-spiffe-credentials/ca_certificates.pem"

Jika sertifikat pada langkah sebelumnya tidak tersedia, lakukan hal berikut:

  gcloud privateca subordinates describe SUBORDINATE_CA_POOL_NAME 

    --location=LOCATION

Pastikan bidang kontrol GKE memiliki binding peran IAM yang benar, sehingga memberikan akses ke Layanan CA:

# Get the IAM policy for the CA
gcloud privateca roots get-iam-policy ROOT_CA_POOL_NAME

# Verify that there is an IAM binding granting access in the following format
- members:
- serviceAccount:service-projnumber@container-engine-robot.iam.gserviceaccount.com
role: roles/privateca.certificateManager

# Where projnumber is the project number (e.g. 2915810291) for the GKE cluster.

Pastikan masa berlaku sertifikat belum habis. Berikut adalah rantai sertifikat dan sertifikat entitas akhir di /var/run/secrets/workload-spiffe-credentials/certificates.pem. Untuk memeriksa, jalankan perintah ini:
```
cat /var/run/secrets/workload-spiffe-credentials/certificates.pem | openssl x509 -text -noout | grep "Not After"
```

Verifikasi bahwa jenis kunci didukung oleh aplikasi Anda dengan menjalankan perintah ini:

cat /var/run/secrets/workload-spiffe-credentials/certificates.pem | openssl x509 -text -noout | grep "Public Key Algorithm" -A 3

Verifikasi bahwa aplikasi gRPC Java Anda memiliki keyAlgorithm berikut dalam file YAML WorkloadCertificateConfig:

  keyAlgorithm:
    rsa:
      modulusSize: 4096

Verifikasi bahwa CA menggunakan family kunci yang sama dengan kunci sertifikat.

Sertifikat aplikasi ditolak oleh klien, server, atau peer

Pastikan aplikasi peer menggunakan paket kepercayaan yang sama untuk memverifikasi sertifikat.
Pastikan masa berlaku sertifikat yang digunakan belum habis (rantai sertifikat beserta sertifikat entitas akhir: "/var/run/secrets/workload-spiffe-credentials/certificates.pem").

Pod tetap dalam status tertunda

Jika Pod tetap dalam status tertunda selama proses penyiapan, tingkatkan resource CPU dan memori untuk Pod dalam spesifikasi deployment Anda.

Tidak dapat membuat cluster dengan flag `--enable-mesh-certificates`

Pastikan Anda menjalankan gcloud CLI versi terbaru:

gcloud components update

Perhatikan bahwa tanda --enable-mesh-certificates hanya berfungsi dengan gcloud beta.

Pod tidak dimulai

Pod yang menggunakan sertifikat mesh GKE mungkin gagal dimulai jika penyediaan sertifikat gagal. Hal ini dapat terjadi dalam situasi seperti berikut:

WorkloadCertificateConfig atau TrustConfig salah dikonfigurasi atau tidak ada.
CSR tidak disetujui.

Anda dapat memeriksa apakah penyediaan sertifikat gagal dengan memeriksa peristiwa Pod.

Periksa status Pod Anda:
```
kubectl get pod -n POD_NAMESPACE POD_NAME
```
Ganti kode berikut:
- POD_NAMESPACE: namespace Pod Anda.
- POD_NAME: nama Pod Anda.

Periksa peristiwa terbaru untuk Pod Anda:

kubectl describe pod -n POD_NAMESPACE POD_NAME

Jika penyediaan sertifikat gagal, Anda akan melihat peristiwa dengan Type=Warning, Reason=FailedMount, From=kubelet, dan kolom Message yang dimulai dengan MountVolume.SetUp failed for volume "gke-workload-certificates". Kolom Message berisi informasi pemecahan masalah.

Events:
  Type     Reason       Age                From       Message
  ----     ------       ----               ----       -------
  Warning  FailedMount  13s (x7 over 46s)  kubelet    MountVolume.SetUp failed for volume "gke-workload-certificates" : rpc error: code = Internal desc = unable to mount volume: store.CreateVolume, err: unable to create volume "csi-4d540ed59ef937fbb41a9bf5380a5a534edb3eedf037fe64be36bab0abf45c9c": caPEM is nil (check active WorkloadCertificateConfig)

Lihat langkah-langkah pemecahan masalah berikut jika alasan Pod Anda tidak dimulai adalah karena objek yang salah dikonfigurasi, atau karena CSR ditolak.

`WorkloadCertificateConfig` atau `TrustConfig` salah dikonfigurasi

Pastikan Anda membuat objek WorkloadCertificateConfig dan TrustConfig dengan benar. Anda dapat mendiagnosis kesalahan konfigurasi pada salah satu objek ini menggunakan kubectl.

Mengambil status saat ini.

Untuk WorkloadCertificateConfig:

kubectl get WorkloadCertificateConfig default -o yaml

Untuk TrustConfig:

kubectl get TrustConfig default -o yaml

Periksa output status. Objek yang valid akan memiliki kondisi dengan type: Ready dan status: "True".
```
status:
  conditions:
  - lastTransitionTime: "2021-03-04T22:24:11Z"
    message: WorkloadCertificateConfig is ready
    observedGeneration: 1
    reason: ConfigReady
    status: "True"
    type: Ready
```
Untuk objek yang tidak valid, status: "False" akan muncul. Kolomreasondan message berisi detail pemecahan masalah tambahan.

CSR tidak disetujui

Jika terjadi masalah selama proses persetujuan CSR, Anda dapat memeriksa detail error dalam kondisi type: Approved dan type: Issued CSR.

Mencantumkan CSR yang relevan menggunakan kubectl:

kubectl get csr \
  --field-selector='spec.signerName=spiffe.gke.io/spiffe-leaf-signer'

Pilih CSR yang Approved dan bukan Issued, atau bukan Approved.
Dapatkan detail untuk CSR yang dipilih menggunakan kubectl:
```
kubectl get csr CSR_NAME -o yaml
```
Ganti CSR_NAME dengan nama CSR yang Anda pilih.

CSR yang valid memiliki kondisi dengan type: Approved dan status: "True", serta sertifikat yang valid di kolom status.certificate:

status:
  certificate: <base64-encoded data>
  conditions:
  - lastTransitionTime: "2021-03-04T21:58:46Z"
    lastUpdateTime: "2021-03-04T21:58:46Z"
    message: Approved CSR because it is a valid SPIFFE SVID for the correct identity.
    reason: AutoApproved
    status: "True"
    type: Approved

Informasi pemecahan masalah untuk CSR yang tidak valid muncul di kolom message dan reason.

Pod tidak memiliki sertifikat

Dapatkan spesifikasi Pod untuk Pod Anda:
```
kubectl get pod -n POD_NAMESPACE POD_NAME -o yaml
```
Ganti kode berikut:
- POD_NAMESPACE: namespace Pod Anda.
- POD_NAME: nama Pod Anda.
Pastikan spesifikasi Pod berisi anotasi security.cloud.google.com/use-workload-certificates yang dijelaskan dalam Mengonfigurasi Pod untuk menerima kredensial mTLS.
Verifikasi bahwa pengontrol penerimaan sertifikat mesh GKE berhasil menyuntikkan volume driver CSI berjenis workloadcertificates.security.cloud.google.com ke dalam spesifikasi Pod Anda:
```
volumes:
...
-csi:
  driver: workloadcertificates.security.cloud.google.com
  name: gke-workload-certificates
...
```

Periksa keberadaan pemasangan volume di setiap penampung:

containers:
- name: ...
  ...
  volumeMounts:
  - mountPath: /var/run/secrets/workload-spiffe-credentials
    name: gke-workload-certificates
    readOnly: true
  ...

Pastikan bahwa paket sertifikat dan kunci pribadi berikut tersedia di lokasi berikut dalam Pod:
- Paket rantai sertifikat: /var/run/secrets/workload-spiffe-credentials/certificates.pem
- Kunci pribadi: /var/run/secrets/workload-spiffe-credentials/private_key.pem
- Paket trust anchor CA: /var/run/secrets/workload-spiffe-credentials/ca_certificates.pem
Jika file tidak tersedia, lakukan langkah-langkah berikut:
1. Ambil instance CA Service (Pratinjau) untuk cluster:
```
kubectl get workloadcertificateconfigs default -o jsonpath '{.spec.certificateAuthorityConfig.certificateAuthorityServiceConfig.endpointURI}'
```
2. Ambil status instance Layanan CA (Pratinjau):
```
gcloud privateca ISSUING_CA_TYPE describe ISSUING_CA_NAME \
  --location ISSUING_CA_LOCATION
```
  Ganti kode berikut:
  - ISSUING_CA_TYPE: jenis CA penerbit, yang harus berupa subordinates atau roots.
  - ISSUING_CA_NAME: nama CA penerbit.
  - ISSUING_CA_LOCATION: region CA penerbit.
3. Dapatkan kebijakan IAM untuk CA root:
```
gcloud privateca roots get-iam-policy ROOT_CA_NAME
```
  Ganti ROOT_CA_NAME dengan nama CA root Anda.
4. Dalam kebijakan IAM, pastikan binding kebijakan privateca.auditor ada:
```
...
- members:
  - serviceAccount:service-PROJECT_NUMBER@container-engine-robot.iam.gserviceaccount.com
  role: roles/privateca.auditor
...
```
  Dalam contoh ini, PROJECT_NUMBER adalah nomor project cluster Anda.
5. Dapatkan kebijakan IAM untuk CA subordinat:
```
gcloud privateca subordinates get-iam-policy SUBORDINATE_CA_NAME
```
  Ganti SUBORDINATE_CA_NAME dengan nama CA subordinat.
6. Dalam kebijakan IAM, pastikan binding kebijakan privateca.certificateManager ada:
```
...
- members:
  - serviceAccount: service-PROJECT_NUMBER@container-engine-robot.iam.gserviceaccount.com
  role: roles/privateca.certificateManager
...
```
  Dalam contoh ini, PROJECT_NUMBER adalah nomor project cluster Anda.

Aplikasi tidak dapat menggunakan kredensial mTLS yang dikeluarkan

Pastikan masa berlaku sertifikat belum habis:

cat /var/run/secrets/workload-spiffe-credentials/certificates.pem | openssl x509 -text -noout | grep "Not After"

Periksa apakah jenis kunci yang Anda gunakan didukung oleh aplikasi Anda.

cat /var/run/secrets/workload-spiffe-credentials/certificates.pem | openssl x509 -text -noout | grep "Public Key Algorithm" -A 3

Pastikan CA penerbit menggunakan keluarga kunci yang sama dengan kunci sertifikat.
1. Dapatkan status instance CA Service (Pratinjau):
```
gcloud privateca ISSUING_CA_TYPE describe ISSUING_CA_NAME \
  --location ISSUING_CA_LOCATION
```
  Ganti kode berikut:
  - ISSUING_CA_TYPE: jenis CA penerbit, yang harus berupa subordinates atau roots.
  - ISSUING_CA_NAME: nama CA penerbit.
  - ISSUING_CA_LOCATION: region CA penerbit.
2. Pastikan keySpec.algorithm dalam output adalah algoritma kunci yang sama dengan yang Anda tetapkan dalam manifes YAML WorkloadCertificateConfig. Outputnya akan terlihat seperti ini:
```
config:
  ...
  subjectConfig:
    commonName: td-sub-ca
    subject:
      organization: TestOrgLLC
    subjectAltName: {}
createTime: '2021-05-04T05:37:58.329293525Z'
issuingOptions:
  includeCaCertUrl: true
keySpec:
  algorithm: RSA_PKCS1_2048_SHA256
 ...
```

Sertifikat ditolak

Pastikan aplikasi peer menggunakan paket kepercayaan yang sama untuk memverifikasi sertifikat.

Pastikan masa berlaku sertifikat belum habis:

cat /var/run/secrets/workload-spiffe-credentials/certificates.pem | openssl x509 -text -noout | grep "Not After"

Verifikasi bahwa kode klien, jika tidak menggunakan Credentials Reloading API gRPC Go, secara berkala memperbarui kredensial dari sistem file.
Pastikan bahwa beban kerja Anda berada di domain tepercaya yang sama dengan CA Anda. Sertifikat mesh GKE mendukung komunikasi antar-workload dalam satu domain tepercaya.

Batasan

Keamanan layanan Cloud Service Mesh hanya didukung dengan GKE. Anda tidak dapat men-deploy keamanan layanan dengan Compute Engine.

Cloud Service Mesh tidak mendukung skenario saat ada dua atau lebih resource kebijakan endpoint yang cocok secara setara dengan endpoint, misalnya, dua kebijakan dengan label dan port yang sama, atau dua kebijakan atau lebih dengan label berbeda yang cocok secara setara dengan label endpoint. Untuk mengetahui informasi selengkapnya tentang cara kebijakan endpoint dicocokkan dengan label endpoint, lihat API untuk EndpointPolicy.EndpointMatcher.MetadataLabelMatcher. Dalam situasi seperti itu, Cloud Service Mesh tidak membuat konfigurasi keamanan dari kebijakan yang bertentangan.

Menyiapkan keamanan layanan dengan gRPC tanpa proxy

Persyaratan

Mengonfigurasi Identity and Access Management

Bersiap untuk melakukan penyiapan

Mengupdate klien dan server gRPC ke versi yang benar

Perbarui file bootstrap

Ringkasan penyiapan

Update Google Cloud CLI

Menyiapkan variabel lingkungan

Mengaktifkan akses ke API yang diperlukan

Membuat atau mengupdate cluster GKE

Mendaftarkan cluster ke fleet

Membuat certificate authority untuk menerbitkan sertifikat

Membuat layanan gRPC tanpa proxy dengan NEG

Java

C++

Python

Go

Mengonfigurasi Cloud Service Mesh dengan Google Cloud komponen load balancing

Buat health check, aturan firewall, dan layanan backend

Membuat resource Mesh dan GRPCRoute

Mengonfigurasi Cloud Service Mesh dengan Keamanan gRPC tanpa proxy

Format untuk referensi kebijakan

Mengonfigurasi mTLS di sisi server

Mengonfigurasi mTLS di sisi klien

Memverifikasi konfigurasi

Membuat klien gRPC tanpa proxy

Java

C++

Python

Go

Menjalankan server

Java

C++

Python

Go

Jalankan klien dan verifikasi konfigurasi

Java

C++

Python

Go

Mengonfigurasi akses tingkat layanan dengan kebijakan otorisasi

gcloud

Memvalidasi kebijakan otorisasi

Java

Go

Menggunakan TLS, bukan mTLS

Menggunakan keamanan layanan dengan contoh Wallet

Java

C++

Go

File bootstrap

Pembaruan pada file bootstrap untuk layanan keamanan

Kolom konfigurasi keamanan dalam file bootstrap

Generator bootstrap

Menghapus deployment

Pemecahan masalah

Workload tidak dapat mengambil konfigurasi dari Cloud Service Mesh

Server gRPC Anda tidak menggunakan TLS/mTLS meskipun dengan konfigurasi Cloud Service Mesh yang benar

Anda tidak dapat membuat cluster GKE dengan versi cluster yang diminta

Anda melihat error No usable endpoint

Workload tidak dapat berkomunikasi dalam penyiapan keamanan

Klien gagal dengan CertificateException dan pesan Peer certificate SAN check failed

Aplikasi tidak dapat menggunakan sertifikat mTLS dengan library gRPC Anda

Sertifikat aplikasi ditolak oleh klien, server, atau peer

Pod tetap dalam status tertunda

Tidak dapat membuat cluster dengan flag --enable-mesh-certificates

Pod tidak dimulai

WorkloadCertificateConfig atau TrustConfig salah dikonfigurasi

CSR tidak disetujui

Pod tidak memiliki sertifikat

Aplikasi tidak dapat menggunakan kredensial mTLS yang dikeluarkan

Sertifikat ditolak

Batasan

Membuat resource `Mesh` dan `GRPCRoute`

Anda melihat error `No usable endpoint`

Klien gagal dengan `CertificateException` dan pesan `Peer certificate SAN check failed`

Tidak dapat membuat cluster dengan flag `--enable-mesh-certificates`

`WorkloadCertificateConfig` atau `TrustConfig` salah dikonfigurasi