Deploy a gRPC service in Knative to improve network efficiency - Container Service for Kubernetes: Central de Documentação do Alibaba Cloud

O ACK Knative suporta os protocolos HTTP e HTTP/2, incluindo gRPC. Este guia mostra como implantar um serviço gRPC ao criar um Knative Service com a configuração de porta correta e verificá-lo com um cliente gRPC.

Pré-requisitos

Antes de começar, certifique-se de ter:

Implantado o Knative em seu cluster. Para mais informações, consulte Deploy Knative.

Como funciona

O gRPC opera sobre HTTP/2. O Knative identifica o tráfego gRPC pelo campo name na especificação do Knative Service. Esse campo deve ter o valor h2c (HTTP/2 cleartext). Se o nome da porta estiver ausente ou incorreto, o gateway do Knative não roteará o tráfego gRPC para o serviço. Com o nome da porta configurado corretamente, o gateway do Knative gerencia todo o roteamento gRPC automaticamente.

Implante o serviço gRPC

Faça login no Container Service Management Console. No painel de navegação à esquerda, clique em ACK consoleClusters.
Na página Clusters, clique no nome do cluster. No painel de navegação à esquerda, escolha Applications > Knative.
Na página Knative, clique na aba Services. Defina o Namespace como default e clique em Create from Template. Na lista suspensa Sample Template, selecione custom. Cole o YAML abaixo no editor de modelos e clique em Create. Essa ação cria um Knative Service chamado helloworld-grpc com a imagem de teste grpcbin, que expõe vários métodos gRPC para testes.

O campo name: h2c em ports é obrigatório. O Knative usa esse nome para identificar o tráfego HTTP/2 (gRPC) e roteá-lo corretamente.
```
apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: helloworld-grpc
spec:
  template:
    metadata:
      annotations:
        autoscaling.knative.dev/class: mpa.autoscaling.knative.dev
    spec:
      containers:
      - image: docker.io/moul/grpcbin
        env:
        - name: TARGET
          value: "Knative"
        ports:
        - containerPort: 9000
          name: h2c    # Required: identifies HTTP/2 (gRPC) traffic
          protocol: TCP
```
Vincule o domínio padrão do serviço ao endereço IP do gateway ao adicionar uma entrada ao arquivo hosts local. Na página Knative, clique na aba Services, clique no nome do serviço helloworld-grpc e anote o IP do Gateway na página de detalhes do serviço. Adicione a seguinte linha ao arquivo hosts (/etc/hosts no Linux e macOS, C:\Windows\System32\drivers\etc\hosts no Windows) e substitua o endereço IP pelo IP real do gateway:
```
121.xx.xxx.xx helloworld-grpc.default.example.com
```

Verifique o serviço gRPC

O formato do caminho de requisição gRPC é {Package}.{Service}/{Method}. Por exemplo, para chamar o método Index do serviço GRPCBin no pacote grpcbin, use o caminho grpcbin.GRPCBin/Index.

Verificação com BloomRPC

O BloomRPC é um cliente GUI para testar serviços gRPC.

Baixe e instale o BloomRPC para o seu sistema operacional.

Salve a definição Protocol Buffers abaixo em um arquivo local chamado gRPC.proto.

syntax = "proto3";

package grpcbin;

service GRPCBin {
  rpc Index(EmptyMessage) returns (IndexReply) {}
  // Returns an empty response.
  rpc Empty(EmptyMessage) returns (EmptyMessage) {}
  // Returns the request parameters as-is.
  rpc DummyUnary(DummyMessage) returns (DummyMessage) {}
  // Server streaming: sends 10 response messages.
  rpc DummyServerStream(DummyMessage) returns (stream DummyMessage) {}
  // Client streaming: accepts 10 requests and returns the last request body.
  rpc DummyClientStream(stream DummyMessage) returns (DummyMessage) {}
  // Bidirectional streaming.
  rpc DummyBidirectionalStreamStream(stream DummyMessage) returns (stream DummyMessage) {}
  // Returns a specified gRPC error.
  rpc SpecificError(SpecificErrorRequest) returns (EmptyMessage) {}
  // Returns a random error.
  rpc RandomError(EmptyMessage) returns (EmptyMessage) {}
  // Returns request headers.
  rpc HeadersUnary(EmptyMessage) returns (HeadersMessage) {}
  // Returns no response.
  rpc NoResponseUnary(EmptyMessage) returns (EmptyMessage) {}
}

message HeadersMessage {
  message Values {
    repeated string values = 1;
  }
  map<string, Values> Metadata = 1;
}

message SpecificErrorRequest {
  uint32 code = 1;
  string reason = 2;
}

message EmptyMessage {}

message DummyMessage {
  message Sub {
    string f_string = 1;
  }
  enum Enum {
    ENUM_0 = 0;
    ENUM_1 = 1;
    ENUM_2 = 2;
  }
  string f_string = 1;
  repeated string f_strings = 2;
  int32 f_int32 = 3;
  repeated int32 f_int32s = 4;
  Enum f_enum = 5;
  repeated Enum f_enums = 6;
  Sub f_sub = 7;
  repeated Sub f_subs = 8;
  bool f_bool = 9;
  repeated bool f_bools = 10;
  int64 f_int64 = 11;
  repeated int64 f_int64s= 12;
  bytes f_bytes = 13;
  repeated bytes f_bytess = 14;
  float f_float = 15;
  repeated float f_floats = 16;
}

message IndexReply {
  message Endpoint {
    string path = 1;
    string description = 2;
  }
  string description = 1;
  repeated Endpoint endpoints = 2;
}

Importe o gRPC.proto para o BloomRPC.
No painel de navegação à esquerda, clique em DummyUnary. No topo da página, insira o endereço do servidor no formato <domain>:<port>:
```
helloworld-grpc.default.example.com:80
```
Clique no botão verde de execução. Se o servidor retornar uma resposta sem erros, o serviço estará funcionando corretamente.

Próximos passos

Configure um certificado HTTPS para o domínio personalizado. Para mais informações, consulte Configurar acesso com certificado HTTPS.