Anthos Service Mesh e Traffic Director sono ora Cloud Service Mesh. Per saperne di più, consulta la panoramica di Cloud Service Mesh.

Questa pagina è stata tradotta dall'API Cloud Translation.

Configura un mesh di servizi gRPC senza proxy

Questa guida illustra come configurare un mesh di servizi gRPC senza proxy.

La configurazione è supportata per i clienti Preview, ma non è consigliata per i nuovi utenti di Cloud Service Mesh. Per ulteriori informazioni, consulta Panoramica di Cloud Service Mesh.

Prima di iniziare

Non creare un mesh di servizi gRPC proxyless in uno spazio dei nomi in cui è abilitata l'iniezione automatica del sidecar Envoy. Per determinare se l'iniezione di file collaterali è abilitato, esegui questo comando:

kubectl get namespace default --show-labels

Se l'inserimento automatico del file collaterale è abilitato, esegui questo comando per rimuovere l'etichetta:

kubectl label namespace default istio-injection-

Esegui il deployment di un servizio gRPC

In questa sezione esegui il deployment di un servizio di esempio helloworld gRPC. Il servizio di esempio helloworld è un'applicazione server gRPC che restituisce un semplice messaggio in risposta alla richiesta di un client gRPC. Il servizio helloworld espone il servizio gRPC sulla porta 8080 nel cluster.

Nel file grpc-td-helloworld.yaml, salva quanto segue:

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

Applica il file grpc-td-helloworld.yaml:

kubectl apply -f grpc-td-helloworld.yaml

Verifica che il nuovo servizio helloworld sia stato creato:

kubectl get svc -n default

L'output è simile al seguente:

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

Verifica che il pod dell'applicazione sia in esecuzione:
```
kubectl get pods -n default
```

I pod di output dovrebbero essere simili ai seguenti:

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

configura un mesh di servizi gRPC

In questa sezione viene configurato un semplice service mesh gRPC.

Nel file td-grpc-mesh.yaml, salva il seguente manifest 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

Applica il manifest del mesh a gke-1:
```
kubectl apply -f td-grpc-mesh.yaml
```
L'esempio TDMesh consente di collegare solo risorse TDGRPCRoute. Il file manifest definisce i tipi di percorso consentiti.

Verifica che il nuovo mesh td-grpc-mesh sia stato creato:

kubectl describe tdmesh td-grpc-mesh -n default

L'output è simile al seguente:

...
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

Nel file helloworld-route.yaml, salva il seguente manifest:

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

Applica il manifest helloworld-route.yaml a gke-1:
```
kubectl apply -f helloworld-route.yaml
```
Verifica che sia stata creata la nuova risorsa helloworld-route GRPCRoute:
```
kubectl get tdgrpcroute -n default
```

Verificare la configurazione

Una volta completato il processo di configurazione, verifica di poter raggiungere le helloworld server gRPC utilizzando un client gRPC senza proxy. Questo client si connette a Cloud Service Mesh, ottiene informazioni sul servizio helloworld e le utilizza per inviare traffico ai backend del servizio.

Nell'esempio seguente, viene utilizzato lo strumento grpcurl per verificare che il parametro Cloud Service Mesh sta indirizzando il traffico correttamente nel mesh. Crea un pod client, poi apri una shell ed esegui i comandi di verifica dalla shell.

configura la variabile di ambiente e il file di bootstrap

In un file grpc-client.yaml, salva il seguente manifest del 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

Applica il manifest del pod in gke-1:
```
kubectl apply -f grpc-client.yaml
```
Quando il pod è pronto, apri una shell per il pod client:
```
kubectl exec -it static-sleeper -- /bin/sh
```

Puoi utilizzare lo strumento grpcurl come client gRPC senza proxy. Lo strumento grpcurl utilizza le informazioni variabile di ambiente e del bootstrap per connettersi Cloud Service Mesh. Lo strumento acquisisce quindi informazioni sul servizio helloworld, che è stato configurato con Cloud Service Mesh.

Per verificare la configurazione utilizzando lo strumento grpcurl:

Scarica e installa lo strumento 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

Esegui lo strumento grpcurl con xds:///helloworld come URI del servizio e helloworld.Greeter/SayHello come nome del servizio e metodo da richiamare. La I parametri al metodo SayHello vengono passati utilizzando l'opzione -d:
```
./grpcurl --plaintext \
  -d '{"name": "world"}' \
  xds:///helloworld helloworld.Greeter/SayHello
```
L'output è simile al seguente, dove INSTANCE_HOST_NAME è il nome host del pod:
```
Greetings: Hello world, from INSTANCE_HOST_NAME
```

L'output verifica che il client gRPC senza proxy si sia connesso correttamente a Cloud Service Mesh e abbia appreso i backend per il servizio helloworld utilizzando il resolver dei nomi xds. Il client ha inviato una richiesta a uno dei senza dover conoscere l'indirizzo IP o eseguire una risoluzione DNS.

Passaggi successivi

Scopri come risolvere i problemi relativi al deployment.