O Anthos Service Mesh e o Traffic Director agora são Cloud Service Mesh. Para mais informações, consulte a Visão geral do Cloud Service Mesh.

Esta página foi traduzida pela API Cloud Translation.

Configurar uma malha de serviço gRPC sem proxy

Este guia mostra como configurar uma malha de serviço gRPC sem proxy.

A configuração é compatível com clientes de pré-lançamento, mas não recomendamos para novos usuários do Cloud Service Mesh. Para mais informações, consulte a Visão geral do Cloud Service Mesh.

Antes de começar

Não crie uma malha de serviço gRPC sem proxy em um namespace em que a injeção automática de arquivo secundário do Envoy esteja ativada. Para determinar se a injeção de arquivo secundário está ativada, execute o seguinte comando:

kubectl get namespace default --show-labels

Se a injeção automática de arquivo secundário estiver ativada, execute este comando para remover o rótulo:

kubectl label namespace default istio-injection-

Implantar um serviço gRPC

Nesta seção, você implantará um serviço de exemplo helloworld do gRPC. O serviço de exemplo helloworld é um aplicativo do servidor gRPC que retorna uma mensagem simples em resposta à solicitação de um cliente gRPC. O serviço helloworld expõe o serviço gRPC na porta 8080 no cluster.

No arquivo grpc-td-helloworld.yaml, salve o seguinte:

apiVersion: v1
kind: Service
metadata:
  name: helloworld
  namespace: default
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
  namespace: default
spec:
  selector:
    matchLabels:
      run: app1
  replicas: 2
  template:
    metadata:
      labels:
        run: app1
      annotations:
        sidecar.istio.io/inject: "false"
    spec:
      containers:
      - image: grpc/java-example-hostname:1.37.0
        name: app1
        ports:
        - protocol: TCP
          containerPort: 50051

Aplique o arquivo grpc-td-helloworld.yaml:

kubectl apply -f grpc-td-helloworld.yaml

Verifique se o novo serviço helloworld foi criado:

kubectl get svc -n default

A saída será assim:

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

Verifique se o pod do aplicativo está em execução:
```
kubectl get pods -n default
```

Os pods de saída precisam ser semelhantes aos seguintes:

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

Configurar uma malha de serviço gRPC

Nesta seção, você configura uma malha de serviço gRPC simples.

No arquivo td-grpc-mesh.yaml, salve o seguinte manifesto mesh:

kind: TDMesh
apiVersion: net.gke.io/v1alpha1
metadata:
  name: td-grpc-mesh
  namespace: default
spec:
  gatewayClassName: gke-td
  allowedRoutes:
    namespaces:
      from: All
    kinds:
    - group: net.gke.io
      kind: TDGRPCRoute

Aplique o manifesto da malha a gke-1:
```
kubectl apply -f td-grpc-mesh.yaml
```
O TDMesh de exemplo permite que apenas recursos TDGRPCRoute sejam anexados a ele. O manifesto define quais tipos de rota são permitidos.

Verifique se a nova malha td-grpc-mesh foi criada:

kubectl describe tdmesh td-grpc-mesh -n default

A saída será assim:

...
Status:
  Conditions:
    Last Transition Time:  2022-04-14T22:22:09Z
    Message:
    Reason:                MeshReady
    Status:                True
    Type:                  Ready
    Last Transition Time:  2022-04-14T22:21:41Z
    Message:
    Reason:                Scheduled
    Status:                True
    Type:                  Scheduled
Events:
  Type    Reason  Age   From                Message
  ----    ------  ----  ----                -------
  Normal  ADD     79s   mc-mesh-controller  Processing mesh default/td-grpc-mesh
  Normal  UPDATE  79s   mc-mesh-controller  Processing mesh default/td-grpc-mesh
  Normal  SYNC    50s   mc-mesh-controller  SYNC on default/td-grpc-mesh was a success

No arquivo helloworld-route.yaml, salve o seguinte manifesto:

kind: TDGRPCRoute
apiVersion: net.gke.io/v1alpha1
metadata:
  name: helloworld-route
  namespace: default
spec:
  parentRefs:
  - name: td-grpc-mesh
    namespace: default
    group: net.gke.io
    kind: TDMesh
  hostnames:
  - helloworld
  rules:
  - backendRefs:
    - name: helloworld
      port: 8080
      namespace: default

Aplique o manifesto helloworld-route.yaml a gke-1:
```
kubectl apply -f helloworld-route.yaml
```
Verifique se o novo recurso helloworld-route GRPCRoute foi criado:
```
kubectl get tdgrpcroute -n default
```

Verificar a configuração

Quando o processo de configuração estiver concluído, verifique se é possível acessar o servidor gRPC helloworld usando um cliente gRPC sem proxy. Esse cliente se conecta a O Cloud Service Mesh recebe informações sobre o serviço helloworld e usa essas informações para enviar o tráfego aos back-ends do serviço.

No exemplo a seguir, você usa a ferramenta grpcurl para verificar se a Cloud Service Mesh está roteando o tráfego corretamente na malha. Crie um pod cliente, abra um shell e execute os comandos de verificação no shell.

Configurar a variável de ambiente e o arquivo de inicialização

Em um arquivo grpc-client.yaml, salve o seguinte manifesto do pod:

apiVersion: v1
kind: Pod
metadata:
  name: static-sleeper
  namespace: default
  annotations:
    sidecar.istio.io/inject: "false"
spec:
  containers:
  - image: curlimages/curl:7.82.0
    imagePullPolicy: IfNotPresent
    name: sleeper
    command:
    - sleep
    - 365d
    env:
    - name: GRPC_XDS_BOOTSTRAP
      value: "/tmp/grpc-xds/td-grpc-bootstrap.json"
    volumeMounts:
    - name: grpc-td-conf
      mountPath: /tmp/grpc-xds/
  initContainers:
  - args:
    - --config-mesh-experimental
    - "gketd-td-grpc-mesh"
    - --output
    - "/tmp/bootstrap/td-grpc-bootstrap.json"
    image: gcr.io/trafficdirector-prod/td-grpc-bootstrap:0.16.0
    imagePullPolicy: IfNotPresent
    name: grpc-td-init
    volumeMounts:
    - name: grpc-td-conf
      mountPath: /tmp/bootstrap/
  volumes:
  - name: grpc-td-conf
    emptyDir:
      medium: Memory

Aplique o manifesto do pod em gke-1:
```
kubectl apply -f grpc-client.yaml
```
Quando o pod estiver pronto, abra um shell para o pod cliente:
```
kubectl exec -it static-sleeper -- /bin/sh
```

É possível usar a ferramenta grpcurl como um cliente gRPC sem proxy. A ferramenta grpcurl usa a variável de ambiente e informações de inicialização para se conectar do Cloud Service Mesh. Em seguida, a ferramenta aprende sobre o serviço helloworld, configurado com o Cloud Service Mesh.

Para verificar a configuração usando a ferramenta grpcurl:

Faça o download e instale a ferramenta grpcurl:

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

Execute a ferramenta grpcurl com xds:///helloworld como o URI do serviço e helloworld.Greeter/SayHello como o nome e o método do serviço a serem invocados. Os parâmetros para o método SayHello são transmitidos usando a opção -d:
```
./grpcurl --plaintext \
  -d '{"name": "world"}' \
  xds:///helloworld helloworld.Greeter/SayHello
```
A saída é semelhante à seguinte, em que INSTANCE_HOST_NAME é o nome do host do pod:
```
Greetings: Hello world, from INSTANCE_HOST_NAME
```

A saída verifica se o cliente gRPC sem proxy se conectou Cloud Service Mesh e aprendeu sobre os back-ends do serviço helloworld usando o resolvedor de nomes xds. O cliente enviou uma solicitação para um dos back-ends do serviço sem precisar saber o endereço IP nem executar a resolução de DNS.

A seguir

Saiba como resolver problemas com sua implantação.