Gunakan ingress gateway untuk mengonfigurasi layanan gRPC berbasis mTLS - Alibaba Cloud Service Mesh

Ingress gateway memungkinkan Anda mengonfigurasi layanan Google Remote Procedure Call (gRPC) yang didasarkan pada protokol mutual TLS (mTLS). Mekanisme keamanan ini memastikan bahwa hanya klien yang berwenang yang dapat mengakses layanan gRPC. Enkripsi ujung-ke-ujung dan otentikasi dua arah diterapkan selama proses transmisi data untuk melindungi informasi dari penyadapan, pemalsuan, dan akses tidak sah.

Prasyarat

Sebuah instance Service Mesh (ASM) edisi Enterprise telah dibuat. Untuk informasi lebih lanjut, lihat Buat instance ASM.
Sebuah klaster ACK dikelola telah dibuat. Untuk informasi lebih lanjut, lihat Buat klaster ACK dikelola.
Klaster telah ditambahkan ke instance ASM.
Sebuah ingress gateway telah diterapkan. Untuk informasi lebih lanjut, lihat Buat ingress gateway.
Sebuah aplikasi telah diterapkan di klaster Container Service for Kubernetes (ACK) yang ditambahkan ke instance ASM Anda. Untuk informasi lebih lanjut, lihat Terapkan aplikasi di klaster ACK yang ditambahkan ke instance ASM.

Informasi latar belakang

Anda dapat mengarahkan trafik ke layanan gRPC dalam instance ASM menggunakan ingress gateway.Service Mesh Layanan gRPC dibangun di atas protokol HTTP/2. Ini memungkinkan Anda menggunakan protokol TLS atau mTLS untuk mengenkripsi data yang ditransmisikan guna memastikan keamanan data. Ingress gateway mendukung gRPC dengan TLS atau mTLS. Penghentian TLS dilakukan pada aliran data TCP terenkripsi saat melewati ingress gateway. Anda tidak perlu mengonfigurasi TLS untuk aplikasi dalam instance ASM.

Prosedur

Langkah 1: Terapkan aplikasi sampel

Masuk ke Konsol ACK. Di panel navigasi sebelah kiri, klik Clusters.
Di halaman Clusters, temukan klaster yang ingin Anda kelola dan klik namanya. Di panel sebelah kiri, pilih Workloads > Deployments.
Di bagian atas halaman Deployments, pilih namespace dari daftar drop-down Namespace dan klik Create from YAML.

Di halaman Create, salin kode YAML berikut ke editor kode dan klik Create.

Kembangkan untuk melihat kode YAML

apiVersion: apps/v1
kind: Deployment
metadata:
  name: istio-grpc-server-v1
  labels:
    app: istio-grpc-server
    version: v1
spec:
  replicas: 1
  selector:
    matchLabels:
      app: istio-grpc-server
      version: v1
  template:
    metadata:
      labels:
        app: istio-grpc-server
        version: v1
    spec:
      containers:
      - args:
        - --address=0.0.0.0:8080
        image: registry.cn-hangzhou.aliyuncs.com/aliacs-app-catalog/istio-grpc-server
        imagePullPolicy: Always
        livenessProbe:
          exec:
            command:
            - /bin/grpc_health_probe
            - -addr=:8080
          initialDelaySeconds: 2
        name: istio-grpc-server
        ports:
        - containerPort: 8080
        readinessProbe:
          exec:
            command:
            - /bin/grpc_health_probe
            - -addr=:8080
          initialDelaySeconds: 2
---
apiVersion: v1
kind: Service
metadata:
  name: istio-grpc-server
  labels:
    app: istio-grpc-server
spec:
  ports:
  - name: grpc-backend
    port: 8080
    protocol: TCP
  selector:
    app: istio-grpc-server
  type: ClusterIP
---

Catatan

Parameter name dari bidang ports dalam konfigurasi layanan harus dimulai dengan http2- atau grpc-. Jika tidak, Istio tidak dapat mengidentifikasi protokol layanan.

Langkah 2: Buat ingress gateway

Dalam contoh ini, port default 443 digunakan untuk mengekspos layanan. Untuk informasi lebih lanjut, lihat Buat ingress gateway.

Langkah 3: Konfigurasikan gateway Istio dan layanan virtual

Masuk ke Konsol ASM. Di panel navigasi sebelah kiri, pilih Service Mesh > Mesh Management.
Di halaman Mesh Management, temukan instance ASM yang ingin Anda konfigurasikan, dan klik nama instansinya atau klik Manage di kolom Actions.

Buat gateway Istio.

Di halaman detail instance ASM, pilih ASM Gateways > Gateway di panel navigasi sebelah kiri.
Di halaman Gateway, klik Create from YAML.

Di halaman Create, pilih default dari daftar drop-down Namespace, salin kode YAML berikut ke editor kode, lalu klik Create.

apiVersion: networking.istio.io/v1beta1
kind: Gateway
metadata:
  name: gw-grpc-443
  namespace: default
spec:
  selector:
    istio: ingressgateway
  servers:
    - hosts:
        - '*'
      port:
        name: https
        number: 443
        protocol: HTTPS
      tls:
        credentialName: example-credential
        mode: MUTUAL

Buat layanan virtual.
1. Di halaman detail instance ASM, pilih Traffic Management Center > VirtualService di panel navigasi sebelah kiri.
2. Di halaman VirtualService, klik Create from YAML.
3. Di halaman Create, pilih default dari daftar drop-down Namespace, salin kode YAML berikut ke editor kode, lalu klik Create.
```
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: grpc-vs
spec:
  hosts:
  - "*"
  gateways:
  - gw-grpc-443
  http:
    - match:
        - port: 443
      route:
        - destination:
            host: istio-grpc-server
```

Langkah 4: Pasang sertifikat

Biasanya, klien gRPC memerlukan sertifikat Subject Alternative Name (SAN). Kami merekomendasikan agar Anda menggunakan sertifikat yang tercantum di grpc-go. Pasang sertifikat ke namespace istio-system klaster ACK karena ingress gateway memerlukan sertifikat tersebut.

Untuk instance ASM versi lebih awal dari 1.17
Jalankan perintah berikut untuk membuat rahasia di namespace istio-system:
```
kubectl create -n istio-system secret generic example-credential --from-file=tls.key=server_key.pem --from-file=tls.crt=server_cert.pem --from-file=ca.crt=client_ca_cert.pem
```
Catatan
Nama rahasia harus sama dengan credentialName yang dikonfigurasikan di gateway Istio.
Untuk instance ASM versi 1.17 atau lebih baru
1. Masuk ke Konsol ASM. Di panel navigasi sebelah kiri, pilih Service Mesh > Mesh Management.
2. Di halaman Mesh Management, klik nama instance ASM. Di panel navigasi sebelah kiri, pilih ASM Gateways > Certificate Management.
3. Di halaman Certificate Management, klik Create. Di panel Certificate Information, konfigurasikan parameter yang diperlukan dan klik OK.

Langkah 5: Mulai klien gRPC

Dalam contoh ini, klien gRPC yang menggunakan mTLS dimulai. Untuk informasi lebih lanjut, lihat situs resmi gRPC.

Instal dependensi. Untuk informasi lebih lanjut, lihat Memulai cepat gRPC di Go.
Clone repositori kode gRPC-go. Untuk informasi lebih lanjut, lihat gRPC-go.

Ganti isi file main.go di jalur /grpc-go/examples/helloworld/greeter_client/ dengan kode berikut dan ubah nilai address menjadi ${Alamat IP ingress gateway}:443:

Kembangkan untuk melihat kode sampel

/*
 *
 * Copyright 2015 gRPC authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

// Package main implements a client for Greeter service.
package main

import (
    "context"
    "crypto/tls"
    "crypto/x509"
    "flag"
    "io/ioutil"
    "log"
    "time"

    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials"
    pb "google.golang.org/grpc/examples/helloworld/helloworld"
)

const (
    defaultName = "world"
)

var (
    addr       = flag.String("addr", "localhost:50051", "the address to connect to")
    name       = flag.String("name", defaultName, "Name to greet")
    cert       = flag.String("cert", "./data/x509/client_cert.pem", "server cert for mTLS")
    key        = flag.String("key", "./data/x509/client_key.pem", "server key for mTLS")
    cacert     = flag.String("cacert", "./data/x509/ca_cert.pem", "ca cert for mTLS")
    servername = flag.String("servername", "x.test.example.com", "the cert name of server")
)

func main() {
    flag.Parse()

    certPair, err := tls.LoadX509KeyPair(*cert, *key)
    if err != nil {
        log.Fatalf("failed to load client cert: %v", err)
    }

    ca := x509.NewCertPool()
    caFilePath := *cacert
    caBytes, err := ioutil.ReadFile(caFilePath)
    if err != nil {
        log.Fatalf("failed to read ca cert %q: %v", caFilePath, err)
    }
    if ok := ca.AppendCertsFromPEM(caBytes); !ok {
        log.Fatalf("failed to parse %q", caFilePath)
    }

    tlsConfig := &tls.Config{
        ServerName:   *servername,
        Certificates: []tls.Certificate{certPair},
        RootCAs:      ca,
    }

    conn, err := grpc.Dial(*addr, grpc.WithTransportCredentials(credentials.NewTLS(tlsConfig)))
    if err != nil {
        log.Fatalf("did not connect: %v", err)
    }
    defer conn.Close()
    c := pb.NewGreeterClient(conn)

    // Contact the server and print out its response.
    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    defer cancel()
    r, err := c.SayHello(ctx, &pb.HelloRequest{Name: *name})
    if err != nil {
        log.Fatalf("could not greet: %v", err)
    }
    log.Printf("Greeting: %s", r.GetMessage())
}

Pergi ke jalur examples dan jalankan perintah berikut:
```
go run helloworld/greeter_client/main.go
```
Hasil yang diharapkan:
```
Greeting: Hello World
```
Jika kesalahan seperti pada gambar berikut ditampilkan, sertifikat tidak valid. Lakukan langkah-langkah sebelumnya untuk memasang sertifikat lagi.