Konfigurasikan layanan gRPC mTLS dengan gerbang ASM - Alibaba Cloud Service Mesh

Anda dapat menggunakan ASM Gateway untuk mengamankan layanan gRPC dengan mutual Transport Layer Security (mTLS). Fitur ini memastikan hanya klien yang berwenang yang dapat mengakses layanan Anda, serta menerapkan enkripsi end-to-end dan otentikasi dua arah guna mencegah penyadapan, perusakan, dan akses tidak sah.

Prasyarat

Buat instans Service Mesh (ASM) Edisi Perusahaan. Untuk informasi selengkapnya, lihat Buat instans ASM.
Kluster ACK yang dikelola telah dibuat. Untuk informasi selengkapnya, lihat Buat kluster ACK yang dikelola.
Kluster telah ditambahkan ke instans ASM.
Terapkan ingress gateway. Untuk informasi selengkapnya, lihat Buat ingress gateway.
Terapkan aplikasi di kluster yang terkait dengan instans ASM. Untuk informasi selengkapnya, lihat Terapkan aplikasi di kluster yang terkait dengan instans ASM.

Latar Belakang

Fitur manajemen traffic Service Mesh memungkinkan Anda mengakses layanan gRPC internal melalui ingress gateway. Karena gRPC berbasis protokol HTTP/2, Anda dapat menggunakan Transport Layer Security (TLS) atau mutual TLS (mTLS) untuk mengenkripsi data dalam transit dan menjamin keamanan komunikasi. ASM Gateway juga mendukung gRPC melalui TLS/mTLS, yang memungkinkan gerbang melakukan terminasi TLS untuk aliran TCP terenkripsi. Dengan demikian, tidak diperlukan konfigurasi TLS terpisah pada aplikasi di dalam service mesh.

Prosedur

Langkah 1: Terapkan aplikasi contoh

Masuk ke Konsol ACK. Di panel navigasi kiri, klik Clusters.
Pada halaman Clusters, klik nama kluster Anda. Di panel navigasi kiri, klik Workloads > Deployments.
Di bagian atas halaman Deployments, pilih namespace dari daftar drop-down Namespace dan klik Create Resources in YAML.

Pada halaman Create, tempel YAML berikut ke editor lalu klik Create.

Expand to view the 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

Karena mekanisme pemilihan protokol Istio, nilai parameter name pada bidang ports dalam konfigurasi Service harus diawali dengan http2- atau grpc-. Jika tidak, Istio tidak dapat mengenali protokol layanan secara benar.

Langkah 2: Terapkan ingress gateway

Contoh ini menggunakan port default 443 untuk mengekspos layanan. Untuk informasi selengkapnya, lihat Buat ingress gateway.

Langkah 3: Konfigurasikan aturan routing Service Mesh

Masuk ke Konsol ASM. Di panel navigasi kiri, pilih Service Mesh > Mesh Management.
Pada halaman Mesh Management, klik nama instans target, atau klik Manage di kolom Actions.

Buat Gateway.

Pada halaman detail instans ASM, pilih ASM Gateways > Gateway di panel navigasi kiri.
Pada halaman Gateway, klik Create from YAML.

Pada halaman Create, pilih default dari daftar drop-down Namespaces, tempel YAML berikut ke editor, 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 VirtualService.
1. Pada halaman detail instans ASM, pilih Traffic Management Center > VirtualService di panel navigasi kiri.
2. Pada halaman VirtualService, klik Create from YAML.
3. Pada halaman Create, pilih default dari daftar drop-down Namespaces, tempel YAML berikut ke editor, 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: Konfigurasikan sertifikat

Klien gRPC biasanya memerlukan sertifikat dengan Subject Alternative Name (SAN). Kami merekomendasikan penggunaan sertifikat contoh dari repositori grpc-go. Sertifikat ini harus dikonfigurasi di namespace istio-system kluster ACK karena digunakan oleh ASM Gateway.

Untuk instans ASM sebelum v1.17

Jalankan perintah berikut untuk membuat Secret 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 Secret harus sesuai dengan nilai credentialName yang ditentukan di Gateway.
Untuk instans ASM v1.17 dan yang lebih baru
1. Masuk ke Konsol ASM. Di panel navigasi kiri, pilih Service Mesh > Mesh Management.
2. Pada halaman Mesh Management, klik nama instans target. Di panel navigasi kiri, pilih ASM Gateways > Certificate Management.
3. Pada halaman Certificate Management, klik Create. Di panel Certificate Information, konfigurasikan parameter lalu klik OK.

Langkah 5: Jalankan klien gRPC

Tutorial ini menggunakan contoh resmi grpc-go sebagai klien gRPC mTLS.

Ikuti tutorial resmi grpc-go untuk menginstal dependensi gRPC. Untuk informasi selengkapnya, lihat Quick start for gRPC in Go.
Ikuti tutorial resmi grpc-go untuk mengkloning repositori kode grpc-go. Untuk informasi selengkapnya, lihat repositori grpc-go.

Ganti isi file /grpc-go/examples/helloworld/greeter_client/main.go dengan kode berikut, lalu ubah nilai address menjadi "<your_asm_gateway_address>:443".

Expand to view the code

/*
 *
 * 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())
}

Setelah mengganti kode, buka direktori examples dan jalankan perintah berikut.
```
go run helloworld/greeter_client/main.go
```
Output yang diharapkan:
```
Greeting: Hello world
```
Jika sertifikat tidak dikonfigurasi dengan benar, klien akan mengembalikan error seperti berikut. Jika hal ini terjadi, ikuti langkah-langkah dalam topik ini untuk mengonfigurasi ulang sertifikat.
```
2022/09/23 15:44:44 could not greet: rpc error: code = Unavailable desc = connection error: desc = "transport: authentication handshake failed: x509: certificate signed by unknown authority"
exit status 1
```