Configure an mTLS gRPC service with an ASM gateway - Alibaba Cloud Service Mesh: Central de Documentação do Alibaba Cloud

Use um Gateway do ASM para proteger seus serviços gRPC com segurança de camada de transporte mútua (mTLS). Esse mecanismo garante que apenas clientes autorizados acessem seus serviços, aplicando criptografia de ponta a ponta e autenticação bidirecional para evitar interceptações, adulterações e acessos não autorizados.

Pré-requisitos

Crie uma instância Enterprise Edition do Service Mesh (ASM). Para mais informações, consulte Criar uma instância do ASM.
Crie um cluster gerenciado do ACK. Para mais informações, consulte Criar um cluster gerenciado do ACK.
Adicione o cluster à instância do ASM.
Implante um gateway de entrada. Para mais informações, consulte Criar um gateway de entrada.
Implante uma aplicação no cluster associado à instância do ASM. Para mais informações, consulte Implantar uma aplicação em um cluster associado a uma instância do ASM.

Contexto

O recurso de gerenciamento de tráfego do Service Mesh permite acessar serviços gRPC internos por meio de um gateway de entrada. Como o gRPC se baseia no protocolo HTTP/2, você pode usar a segurança de camada de transporte (TLS) ou TLS mútuo (mTLS) para criptografar dados em trânsito e garantir sua segurança. O Gateway do ASM também suporta gRPC sobre TLS/mTLS, o que permite ao gateway realizar a terminação TLS para fluxos TCP criptografados. Isso elimina a necessidade de configurações separadas de TLS nas aplicações dentro da malha de serviços.

Procedimento

Etapa 1: Implantar uma aplicação de exemplo

Faça login no console do ACK. No painel de navegação à esquerda, clique em Clusters.
Na página Clusters, clique no nome do seu cluster. No painel de navegação à esquerda, clique em Workloads > Deployments.
No topo da página Deployments, selecione um namespace na lista suspensa Namespace e clique em Create Resources in YAML.

Na página Create, cole o seguinte YAML no editor e clique em Create.

Expandir para visualizar o 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
---

Nota

Devido ao mecanismo de seleção de protocolo do Istio, o valor do parâmetro name no campo ports da configuração do Service deve começar com http2- ou grpc-. Caso contrário, o Istio não identificará corretamente o protocolo do serviço.

Etapa 2: Implantar um gateway de entrada

Este exemplo usa a porta padrão 443 para expor o serviço. Para mais informações, consulte Criar um gateway de entrada.

Etapa 3: Configurar regras de roteamento do Service Mesh

Faça login no console do ASM. No painel de navegação à esquerda, escolha Service Mesh > Mesh Management.
Na página Mesh Management, clique no nome da instância de destino ou clique em Manage na coluna Actions.

Crie um Gateway.

Na página de detalhes da instância do ASM, escolha ASM Gateways > Gateway no painel de navegação à esquerda.
Na página Gateway, clique em Create from YAML.

Na página Create, selecione default na lista suspensa Namespaces, cole o seguinte YAML no editor e clique em 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

Crie um VirtualService.
1. Na página de detalhes da instância do ASM, escolha Traffic Management Center > VirtualService no painel de navegação à esquerda.
2. Na página VirtualService, clique em Create from YAML.
3. Na página Create, selecione default na lista suspensa Namespaces, cole o seguinte YAML no editor e clique em 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
```

Etapa 4: Configurar certificados

Clientes gRPC geralmente exigem certificados com um Nome Alternativo do Assunto (SAN). Recomendamos usar os certificados de exemplo do repositório grpc-go. Configure esses certificados no namespace istio-system do cluster ACK, pois o Gateway do ASM os utiliza.

Para instâncias do ASM anteriores à v1.17

Execute o comando a seguir para criar um Secret no 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
```
Nota
O nome do Secret deve corresponder ao valor de credentialName especificado no Gateway.
Para instâncias do ASM v1.17 e posteriores
1. Faça login no console do ASM. No painel de navegação à esquerda, escolha Service Mesh > Mesh Management.
2. Na página Mesh Management, clique no nome da instância de destino. No painel de navegação à esquerda, escolha ASM Gateways > Certificate Management.
3. Na página Certificate Management, clique em Create. No painel Certificate Information, configure os parâmetros e clique em OK.

Etapa 5: Executar o cliente gRPC

Este tutorial usa o exemplo oficial do grpc-go como cliente gRPC mTLS.

Siga o tutorial oficial do grpc-go para instalar as dependências do gRPC. Para mais informações, consulte Início rápido para gRPC em Go.
Siga o tutorial oficial do grpc-go para clonar o repositório de código grpc-go. Para mais informações, consulte o repositório grpc-go.

Substitua o conteúdo do arquivo /grpc-go/examples/helloworld/greeter_client/main.go pelo código a seguir. Altere o valor de address para ":443".

Expandir para visualizar o código

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

Após substituir o código, acesse o diretório examples e execute o comando a seguir.
```
go run helloworld/greeter_client/main.go
```
Saída esperada:
```
Greeting: Hello world
```
Se os certificados não estiverem configurados corretamente, o cliente retornará um erro semelhante ao seguinte. Nesse caso, siga as etapas deste tópico para configurar os certificados novamente. 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