Versi 1.20

Versi yang tersedia

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

219}

Halaman ini diterjemahkan oleh Cloud Translation API.

Menyiapkan Google Kubernetes Engine dan layanan gRPC tanpa proxy

Panduan ini menjelaskan cara mengonfigurasi Google Kubernetes Engine, aplikasi gRPC, dan komponen load balancing yang diperlukan Cloud Service Mesh.

Sebelum mengikuti petunjuk dalam panduan ini, tinjau Persiapan menyiapkan Cloud Service Mesh dengan layanan gRPC tanpa proxy.

Ringkasan

Menyiapkan Cloud Service Mesh dengan GKE dan layanan gRPC tanpa proxy melibatkan hal berikut:

Menyiapkan cluster GKE Anda.
Men-deploy aplikasi server gRPC sebagai layanan Kubernetes. Beri anotasi Spesifikasi deployment GKE untuk membuat grup endpoint jaringan secara otomatis (NEG) untuk layanan.
Mengonfigurasi Cloud Service Mesh menggunakan NEG dan beban Google Cloud lainnya komponen balancing.
Memverifikasi apakah deployment berfungsi dengan benar menggunakan klien gRPC tanpa proxy aplikasi Google untuk mengirim traffic ke aplikasi server gRPC.

Mengonfigurasi cluster GKE untuk Cloud Service Mesh

Bagian ini memberikan petunjuk untuk mengaktifkan cluster GKE agar dapat digunakan dengan dan Cloud Service Mesh.

Persyaratan cluster GKE

Cluster GKE harus memenuhi persyaratan berikut:

Anda harus mengaktifkan dukungan untuk grup endpoint jaringan. Untuk informasi lebih lanjut dan lihat Grup endpoint jaringan mandiri. Fitur NEG mandiri tersedia di Ketersediaan Umum untuk dan Cloud Service Mesh.
Instance node cluster akun layanan harus memiliki izin untuk mengakses Cloud Service Mesh API. Untuk informasi selengkapnya tentang izin yang diperlukan, lihat Mengaktifkan akun layanan untuk mengakses Cloud Service Mesh API.
Container harus memiliki akses ke Cloud Service Mesh API, yaitu dilindungi oleh otentikasi OAuth. Untuk informasi selengkapnya, lihat konfigurasi host.

Membuat cluster GKE

Contoh berikut menunjukkan cara membuat cluster GKE bernama grpc-td-cluster dalam us-central1-a zone.

Konsol

Untuk membuat cluster menggunakan Konsol Google Cloud, lakukan hal berikut langkah:

Buka menu Kubernetes Engine di Konsol Google Cloud.

Buka menu Google Kubernetes Engine
Klik Buat kluster.
Pilih template Cluster standar atau pilih template yang sesuai atas beban kerja Anda.
Sesuaikan template jika perlu. {i>Field<i} berikut adalah wajib:
- Nama: Masukkan grpc-td-cluster.
- Jenis lokasi: Zonal.
- Zona: us-central1-a.
- Kumpulan node:
Di menu sebelah kiri, klik default-pool.
Ubah Name menjadi grpc-td-cluster.
Pada Ukuran, masukkan jumlah node yang akan dibuat. Anda harus memiliki kuota resource yang tersedia untuk node dan resource-nya (seperti rute firewall).
Di menu sebelah kiri, klik Nodes.
Di bagian Machine Configuration, di Machine family, klik Dioptimalkan untuk Komputasi.
Pilih Machine type. Untuk mengetahui informasi harga jenis mesin, lihat halaman harga Compute Engine.
Di bagian Networking, tambahkan Tag jaringan allow-health-checks.
Di menu sebelah kiri, klik Node security.
Di bagian Cakupan akses, pilih Izinkan akses penuh ke semua Cloud API.
Klik Create.

Setelah membuat cluster di konsol Google Cloud, Anda perlu mengonfigurasi kubectl untuk berinteraksi dengan cluster. Untuk mempelajari lebih lanjut, lihat Membuat entri kubeconfig.

gcloud

Buat cluster.

gcloud container clusters create grpc-td-cluster \
   --zone us-central1-a \
   --scopes=https://www.googleapis.com/auth/cloud-platform \
   --tags=allow-health-checks \
   --enable-ip-alias

Mendapatkan hak istimewa cluster GKE yang diperlukan

Beralihlah ke cluster yang baru saja Anda buat dengan menjalankan perintah berikut. Ini menunjuk kubectl ke cluster yang benar.

gcloud

gcloud container clusters get-credentials grpc-td-cluster \
    --zone us-central1-a

Mengonfigurasi layanan GKE

Bagian ini menjelaskan cara menyiapkan deployment GKE spesifikasi lain untuk berfungsi dengan Cloud Service Mesh. Ini terdiri dari mengonfigurasi layanan contoh helloworld GKE dengan anotasi NEG.

Layanan contoh helloworld adalah aplikasi server gRPC yang menampilkan sebagai respons terhadap permintaan klien gRPC. Perhatikan bahwa ada tidak ada yang istimewa dari layanan helloworld. Ini bukan gRPC tanpa proxy dan dapat merespons permintaan dari klien gRPC.

Opsi "proxyless" hanya mulai berperan ketika aplikasi klien gRPC terhubung ke Cloud Service Mesh, mempelajari layanan helloworld, dan dapat lalu mengirim traffic ke Pod yang terkait dengan helloworld, tanpa perlu mengandalkan alamat IP atau resolusi nama berbasis DNS.

Mengonfigurasi layanan GKE dengan NEG

Langkah pertama dalam mengonfigurasi layanan GKE untuk digunakan dengan Cloud Service Mesh adalah untuk mengekspos layanan melalui NEG. Akan terekspos melalui NEG, setiap spesifikasi harus memiliki anotasi berikut, yang cocok porta yang ingin diekspos.

...
metadata:
  annotations:
    cloud.google.com/neg: '{"exposed_ports":{"8080":{"name": "example-grpc-server"}}}'

Anotasi ini membuat NEG mandiri saat Anda pertama kali men-deploy layanan. NEG ini berisi endpoint yang merupakan alamat IP dan port Pod. Untuk selengkapnya informasi dan contoh, lihat Grup endpoint jaringan mandiri.

Pada contoh berikut, Anda men-deploy layanan Kubernetes helloworld yang diekspos pada port 8080. Ini adalah port tempat layanan terlihat di . Layanan gRPC di Pod memproses 50051 targetPort. Ini adalah porta di Pod yang menjadi tujuan pengiriman permintaan. Biasanya, port dan targetPort ditetapkan ke nilai yang sama demi kemudahan, tetapi contoh ini menggunakan nilai yang berbeda untuk menunjukkan nilai yang benar untuk digunakan dalam anotasi NEG.

cat << EOF > grpc-td-helloworld.yaml
apiVersion: v1
kind: Service
metadata:
  name: helloworld
  annotations:
    cloud.google.com/neg: '{"exposed_ports":{"8080":{"name": "example-grpc-server"}}}'
spec:
  ports:
  - port: 8080
    name: helloworld
    protocol: TCP
    targetPort: 50051
  selector:
    run: app1
  type: ClusterIP

---
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: app1
  name: app1
spec:
  selector:
    matchLabels:
      run: app1
  replicas: 2
  template:
    metadata:
      labels:
        run: app1
    spec:
      containers:
      - image: grpc/java-example-hostname:1.50.2
        name: app1
        ports:
        - protocol: TCP
          containerPort: 50051
EOF

kubectl apply -f grpc-td-helloworld.yaml

Pastikan layanan helloworld baru telah dibuat:

kubectl get svc

Output kubectl get svc akan serupa dengan ini:

NAME           TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
helloworld     ClusterIP   10.71.9.71   <none>        8080/TCP  41m
[..skip..]

Pastikan Pod aplikasi sedang berjalan:

kubectl get pods

Output kubectl get pods akan serupa dengan ini:

NAME                        READY     STATUS    RESTARTS   AGE
app1-6db459dcb9-zvfg2   1/1       Running   0          6m
app1-6db459dcb9-hlvhj   1/1       Running   0          6m
[..skip..]

Pastikan bahwa nama NEG sudah benar.

Konsol

Untuk melihat daftar grup endpoint jaringan, buka Grup Endpoint Jaringan di Konsol Google Cloud. Anda melihat NEG bernama example-grpc-server.
Buka halaman Grup Endpoint Jaringan

gcloud

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

# Optionally examine the NEG
gcloud compute network-endpoint-groups describe example-grpc-server \
    --zone us-central1-a

# Optionally examine the endpoint(s) contained
gcloud compute network-endpoint-groups list-network-endpoints example-grpc-server \
    --zone us-central1-a

Mengonfigurasi Cloud Service Mesh dengan komponen load balancing

Bagian ini menjelaskan cara mengonfigurasi Google Cloud Load Balancing komponen untuk layanan Anda. Komponen ini berisi informasi konfigurasi yang memungkinkan klien gRPC tanpa proxy berkomunikasi dengan GKE Anda layanan IT perusahaan mereka.

Contoh konfigurasi Cloud Service Mesh yang mengikutinya membuat asumsi berikut:

NEG dan semua resource lainnya dibuat di jaringan default mode otomatis, di zona us-central1-a.
Saat menggunakan Google Cloud CLI, nama NEG untuk cluster akan example-grpc-server.

Membuat health check, aturan firewall, dan layanan backend

Di bagian ini, Anda akan membuat health check dan aturan firewall untuk health check. Health check harus menggunakan protokol health check gRPC. Tujuan aturan firewall memungkinkan pemeriksaan health check terhubung ke VM di deployment. Perintah --use-serving-port digunakan oleh health check untuk mendapatkan porta pemrosesan yang dikonfigurasi untuk setiap endpoint.

Aturan firewall mengizinkan koneksi health check yang masuk ke instance di jaringan Anda.

Di bagian ini, Anda akan membuat layanan backend global dengan skema load balancing INTERNAL_SELF_MANAGED dan protokol GRPC, kemudian mengaitkan health check dengan layanan backend.

Untuk mengetahui informasi selengkapnya, lihat Membuat health check.

gcloud

Buat health check.

gcloud compute health-checks create grpc grpc-gke-helloworld-hc \
 --use-serving-port

Membuat aturan firewall.

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

Membuat 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 backend ke layanan backend.

gcloud compute backend-services add-backend grpc-gke-helloworld-service \
   --global \
   --network-endpoint-group example-grpc-server \
   --network-endpoint-group-zone us-central1-a \
   --balancing-mode RATE \
   --max-rate-per-endpoint 5

Membuat peta aturan perutean

Di bagian ini, Anda akan membuat peta URL, pencocok jalur, dan aturan host untuk merutekan lalu lintas untuk layanan Anda, berdasarkan nama {i>host<i} dan jalur. Contoh berikut menggunakan helloworld-gke sebagai nama layanan. Klien gRPC menggunakan nama layanan di URI target saat terhubung ke layanan helloworld. Anda juga akan membuat aturan penerusan dan proxy gRPC target.

Untuk mengetahui informasi selengkapnya, lihat Peta aturan pemilihan rute.

Contoh berikut menggunakan nama layanan helloworld-gke dan port 8000. Artinya, klien gRPC harus menggunakan xds:///helloworld-gke:8000 untuk terhubung ke layanan ini, dan aturan host helloworld-gke:8000 harus dikonfigurasi di Peta URL. Perlu diketahui bahwa port layanan 8080 yang ditampilkan dalam spesifikasi layanan Kubernetes di bagian sebelumnya tidak digunakan oleh Cloud Service Mesh karena helloworld-gke:8000 secara langsung diselesaikan ke endpoint NEG yang memproses targetPort 50051. Biasanya, port dalam aturan host peta URL dan spesifikasi layanan Kubernetes port dan targetPort ditetapkan ke nilai yang sama demi kemudahan, tetapi contoh ini menggunakan nilai yang berbeda untuk menunjukkan bahwa port dalam spesifikasi layanan tidak digunakan oleh Cloud Service Mesh.

gcloud

Membuat peta URL.

gcloud compute url-maps create grpc-gke-url-map \
--default-service grpc-gke-helloworld-service

Buat pencocok jalur.

gcloud compute url-maps add-path-matcher grpc-gke-url-map \
--default-service grpc-gke-helloworld-service \
--path-matcher-name grpc-gke-path-matcher \
--new-hosts helloworld-gke:8000

Buat proxy gRPC target.

gcloud compute target-grpc-proxies create grpc-gke-proxy \
--url-map grpc-gke-url-map \
--validate-for-proxyless

Membuat aturan penerusan.

gcloud compute forwarding-rules create grpc-gke-forwarding-rule \
--global \
--load-balancing-scheme=INTERNAL_SELF_MANAGED \
--address=0.0.0.0 \
--target-grpc-proxy=grpc-gke-proxy \
--ports 8000 \
--network default

Cloud Service Mesh kini dikonfigurasi untuk melakukan load balancing pada traffic di endpoint di NEG untuk layanan yang ditentukan di peta URL.

Memverifikasi konfigurasi

Setelah proses konfigurasi selesai, pastikan Anda dapat mencapai Server gRPC helloworld menggunakan klien gRPC tanpa proxy. Klien ini menghubungkan ke Cloud Service Mesh, memperoleh informasi tentang layanan helloworld (dikonfigurasi dengan Cloud Service Mesh menggunakan grpc-gke-helloworld-service layanan backend) dan menggunakan informasi ini untuk mengirim traffic ke jaringan backend.

Anda juga dapat memeriksa bagian Cloud Service Mesh di Konsol Google Cloud untuk mendapatkan informasi di layanan yang dikonfigurasi helloworld-gke, lalu periksa apakah backend dinyatakan sehat.

Verifikasi dengan klien gRPC tanpa proxy

Pada contoh berikut, Anda menggunakan klien gRPC dalam berbagai bahasa atau Alat grpcurl untuk memverifikasi bahwa Cloud Service Mesh mengarahkan traffic di jaring dengan benar. Anda membuat Pod klien, lalu membuka shell dan menjalankan perintah verifikasi dari {i>shell<i}.

Menyiapkan variabel lingkungan dan file bootstrap

Aplikasi klien memerlukan file konfigurasi bootstrap. Ubah Spesifikasi deployment aplikasi Kubernetes dengan menambahkan initContainer yang menghasilkan file {i>bootstrap<i} dan volume untuk mentransfer file tersebut. Perbarui yang ada untuk mencari file tersebut.

Tambahkan initContainer berikut ke spesifikasi deployment aplikasi:

      initContainers:
      - args:
        - --output
        - "/tmp/bootstrap/td-grpc-bootstrap.json"
        image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.16.0

        imagePullPolicy: IfNotPresent
        name: grpc-td-init
        resources:
          limits:
            cpu: 100m
            memory: 100Mi
          requests:
            cpu: 10m
            memory: 100Mi
        volumeMounts:
        - name: grpc-td-conf
          mountPath: /tmp/bootstrap/
      volumes:
      - name: grpc-td-conf
        emptyDir:
          medium: Memory

Perbarui bagian env penampung aplikasi untuk menyertakan hal berikut:

        env:
        - name: GRPC_XDS_BOOTSTRAP
          value: "/tmp/grpc-xds/td-grpc-bootstrap.json"
        volumeMounts:
        - name: grpc-td-conf
          mountPath: /tmp/grpc-xds/

Berikut adalah contoh lengkap spesifikasi Kubernetes klien:

cat << EOF  | kubectl apply -f -
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: client
  name: sleeper
spec:
  selector:
    matchLabels:
      run: client
  template:
    metadata:
      labels:
        run: client
    spec:
      containers:
      - image: openjdk:8-jdk
        imagePullPolicy: IfNotPresent
        name: sleeper
        command:
        - sleep
        - 365d
        env:
        - name: GRPC_XDS_BOOTSTRAP
          value: "/tmp/grpc-xds/td-grpc-bootstrap.json"
        resources:
          limits:
            cpu: "2"
            memory: 2000Mi
          requests:
            cpu: 300m
            memory: 1500Mi
        volumeMounts:
        - name: grpc-td-conf
          mountPath: /tmp/grpc-xds/
      initContainers:
      - args:
        - --output
        - "/tmp/bootstrap/td-grpc-bootstrap.json"
        image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.16.0
        imagePullPolicy: IfNotPresent
        name: grpc-td-init
        resources:
          limits:
            cpu: 100m
            memory: 100Mi
          requests:
            cpu: 10m
            memory: 100Mi
        volumeMounts:
        - name: grpc-td-conf
          mountPath: /tmp/bootstrap/
      volumes:
      - name: grpc-td-conf
        emptyDir:
          medium: Memory
EOF

Setelah deployment siap, buka shell ke Pod klien.

kubectl exec -it $(kubectl get pods -o custom-columns=:.metadata.name \
    --selector=run=client) -- /bin/bash

Untuk memverifikasi konfigurasi, jalankan contoh yang sesuai di Pod shell.

Java

Untuk memverifikasi layanan dengan klien Java gRPC:

Download versi terbaru gRPC Java, dengan patch dan build terbaru aplikasi klien xds-hello-world.

 curl -L https://github.com/grpc/grpc-java/archive/v1.37.0.tar.gz | tar -xz
 cd grpc-java-1.37.0/examples/example-xds
 ../gradlew --no-daemon installDist

Jalankan klien dengan "world" sebagai namanya dan "xds:///helloworld-gke:8000" sebagai URI dan port layanan.
```
./build/install/example-xds/bin/xds-hello-world-client "world" \
xds:///helloworld-gke:8000
```

Go

Untuk memverifikasi layanan dengan klien gRPC Go:

Download versi terbaru gRPC Go, dengan patch terbaru, dan bangun Aplikasi klien xds-hello-world.

apt-get update -y
apt-get install -y golang git
curl -L https://github.com/grpc/grpc-go/archive/v1.37.0.tar.gz | tar -xz
cd grpc-go-1.37.0/examples/features/xds/client
go get google.golang.org/grpc@v1.37.0
go build .

Jalankan klien dengan "world" sebagai namanya dan "xds:///helloworld-gke:8000" sebagai URI dan port layanan.
```
./client "world" xds:///helloworld-gke:8000
```

C++

Untuk memverifikasi layanan dengan klien C++ gRPC:

Download gRPC C++ versi terbaru,dengan patch terbaru, dan bangun Contoh klien helloworld.

apt-get update -y
apt-get install -y build-essential cmake git
git clone --recurse-submodules -b v1.37.1 https://github.com/grpc/grpc
cd grpc
mkdir -p cmake/build
pushd cmake/build
cmake ../..
make
make install
popd
mkdir -p third_party/abseil-cpp/cmake/build
pushd third_party/abseil-cpp/cmake/build
cmake ../..
make
make install
popd
cd examples/cpp/helloworld
mkdir -p cmake/build
cd cmake/build/
cmake ../..
make

Jalankan klien dengan "xds:///helloworld-gke:8000" sebagai URI dan port layanan.
```
./greeter_client --target=xds:///helloworld-gke:8000
```

Grpcurl

Alat grpcurl juga dapat berfungsi sebagai klien gRPC tanpa proxy. Dalam kasus ini, grpcurl menggunakan variabel lingkungan dan informasi bootstrap untuk terhubung ke Cloud Service Mesh. Kemudian, kode ini mempelajari layanan helloworld, yang dikonfigurasi dengan Cloud Service Mesh melalui grpc-gke-helloworld-service layanan backend.

Untuk memverifikasi konfigurasi Anda menggunakan alat grpcurl:

Download dan instal alat grpcurl.

curl -L https://github.com/fullstorydev/grpcurl/releases/download/v1.8.1/grpcurl_1.8.1_linux_x86_64.tar.gz | tar -xz

Jalankan alat grpcurl dengan "xds:///helloworld-gke:8000" sebagai URI layanan dan helloworld.Greeter/SayHello sebagai nama layanan dan metode yang akan dipanggil. Tujuan parameter ke metode SayHello diteruskan menggunakan opsi -d.
```
./grpcurl --plaintext \
  -d '{"name": "world"}' \
  xds:///helloworld-gke:8000 helloworld.Greeter/SayHello
```

Python

Untuk memverifikasi layanan dengan klien Python gRPC, jalankan perintah berikut. Gunakan gRPC versi terbaru dengan patch terbaru.

apt-get update -y
apt-get install python3-pip -y
pip3 install virtualenv
curl -L https://github.com/grpc/grpc/archive/v1.37.1.tar.gz | tar -xz
cd grpc-1.37.1/examples/python/xds
virtualenv venv -p python3
source venv/bin/activate
pip install -r requirements.txt
python client.py  xds:///helloworld-gke:8000

Ruby

Untuk memverifikasi layanan dengan klien gRPC Ruby, jalankan perintah berikut. Gunakan gRPC versi terbaru dengan patch terbaru.

apt-get update -y
apt-get install -y ruby-full
gem install grpc
curl -L https://github.com/grpc/grpc/archive/v1.37.1.tar.gz | tar -xz
cd grpc-1.37.1/examples/ruby
ruby greeter_client.rb john xds:///helloworld-gke:8000

PHP

Untuk memverifikasi layanan dengan klien PHP gRPC, jalankan perintah berikut. Gunakan gRPC versi terbaru dengan patch terbaru.

apt-get update -y
apt-get install -y php7.3 php7.3-dev php-pear phpunit python-all zlib1g-dev git
pecl install grpc
curl -sS https://getcomposer.org/installer | php
mv composer.phar /usr/local/bin/composer
curl -L https://github.com/grpc/grpc/archive/v1.37.1.tar.gz | tar -xz
cd grpc-1.37.1
export CC=/usr/bin/gcc
./tools/bazel build @com_google_protobuf//:protoc
./tools/bazel build src/compiler:grpc_php_plugin
cd examples/php
composer install
../../bazel-bin/external/com_google_protobuf/protoc --proto_path=../protos \
--php_out=. --grpc_out=. \
--plugin=protoc-gen-grpc=../../bazel-bin/src/compiler/grpc_php_plugin \
../protos/helloworld.proto
php -d extension=grpc.so greeter_client.php john xds:///helloworld-gke:8000

Node.js

Untuk memverifikasi layanan dengan klien gRPC Node.js, jalankan perintah berikut. Gunakan gRPC versi terbaru dengan patch terbaru.

apt-get update -y
apt-get install -y nodejs npm
curl -L https://github.com/grpc/grpc/archive/v1.34.0.tar.gz | tar -xz
cd grpc-1.34.0/examples/node/xds
npm install
node ./greeter_client.js --target=xds:///helloworld-gke:8000

Anda akan melihat output yang mirip dengan ini, dengan INSTANCE_HOST_NAME adalah nama host instance VM:

Greetings: Hello world, from INSTANCE_HOST_NAME

Tindakan ini memverifikasi bahwa klien gRPC tanpa proxy berhasil terhubung Cloud Service Mesh dan mempelajari backend untuk layanan helloworld-gke menggunakan resolver nama xds. Klien mengirim permintaan ke salah satu backend layanan tanpa perlu mengetahui tentang alamat IP atau melakukan resolusi DNS.

Langkah selanjutnya

Pelajari keamanan layanan Cloud Service Mesh.
Pelajari pengelolaan traffic lanjutan.
Pelajari cara menyiapkan kemampuan observasi.
Pelajari cara memecahkan masalah deployment Cloud Service Mesh tanpa proxy.