Anthos Service Mesh y Traffic Director ahora son Cloud Service Mesh. Para obtener más información, consulta la descripción general de Cloud Service Mesh.

Se usó la API de Cloud Translation para traducir esta página.

Configura servicios de TCP

En esta guía, se muestra cómo configurar Cloud Service Mesh para usar servicios de TCP y recursos TCPRoute.

Cloud Service Mesh con servicios de TCP y TCPRoute es similar a la configuración del proxy de sidecar de Envoy con servicios HTTP. Las excepciones son que el servicio de backend proporciona un servicio de TCP y el enrutamiento se basa en los parámetros TCP/IP en lugar del protocolo HTTP.

Recurso Mesh con recurso TCPRoute — Recurso `Mesh` con recurso `TCPRoute` (haz clic para ampliar)

Antes de comenzar

Asegúrate de completar las tareas que se describen en Prepárate para la configuración con Envoy y cargas de trabajo sin proxy.

Configura el recurso `Mesh`

En un archivo llamado mesh.yaml, crea la especificación de recursos mesh.
```
name: sidecar-mesh
```

Usa el archivo mesh.yaml para crear el recurso mesh.

gcloud network-services meshes import sidecar-mesh \
  --source=mesh.yaml \
  --location=global

Configura el servidor de TCP

Esta parte de la guía no es específica de las API nuevas y usa los servicios de backend, las verificaciones de estado y recursos de MIG existentes.

A modo de demostración, crearás un servicio de backend con VM con ajuste de escala automático mediante grupos de instancias administrados que entregan un servicio de TCP de prueba en el puerto 10000.

Crea una plantilla de instancias de VM de Compute Engine con un servicio de prueba en el puerto 10000.

gcloud compute instance-templates create tcp-td-vm-template \
  --scopes=https://www.googleapis.com/auth/cloud-platform \
  --tags=allow-health-checks \
  --image-family=debian-10 \
  --image-project=debian-cloud \
  --metadata=startup-script="#! /bin/bash
sudo apt-get update -y
sudo apt-get install netcat -y
while true;
  do echo 'Hello from TCP service' | nc -l -s 0.0.0.0 -p 10000;
done &"

Crea un grupo de instancias administrado basado en la plantilla.

gcloud compute instance-groups managed create tcp-td-mig-us-east1 \
  --zone=ZONE \
  --size=1 \
  --template=tcp-td-vm-template

Configura los puertos con nombre en el grupo de instancias administrado creado en el puerto 10000.

gcloud compute instance-groups set-named-ports tcp-td-mig-us-east1 

  --zone=ZONE 

  --named-ports=tcp:10000

Cree una verificación de estado.

gcloud compute health-checks create tcp tcp-helloworld-health-check --port 10000

Crea una regla de firewall que permita las conexiones de verificación de estado entrantes a las instancias de tu red.

gcloud compute firewall-rules create tcp-vm-allow-health-checks \
   --network default \
   --action allow \
   --direction INGRESS \
   --source-ranges=35.191.0.0/16,130.211.0.0/22 \
   --target-tags allow-health-checks \
   --rules tcp:10000

Crea un servicio de backend global con un esquema de balanceo de cargas de INTERNAL_SELF_MANAGED y adjunta la verificación de estado al servicio de backend. En el ejemplo, se usa el grupo de instancias administrado que ejecuta el servicio de TCP de muestra que creaste antes.
```
gcloud compute backend-services create tcp-helloworld-service \
    --global \
    --load-balancing-scheme=INTERNAL_SELF_MANAGED \
    --protocol=TCP \
    --health-checks tcp-helloworld-health-check
```

Agrega el grupo de instancias administrado al servicio de backend.

gcloud compute backend-services add-backend tcp-helloworld-service \
  --instance-group tcp-td-mig-us-east1 \
  --instance-group-zone=ZONE \
  --global

Configura el enrutamiento con `TCPRoute`

En esta sección, configurarás el enrutamiento.

En un archivo llamado tcp_route.yaml, crea la especificación TcpRoute.

Puedes usar $PROJECT_ID o $PROJECT_NUMBER.

name: helloworld-tcp-route
meshes:
- projects/$PROJECT_NUMBER/locations/global/meshes/sidecar-mesh
rules:
- action:
    destinations:
    - serviceName: projects/$PROJECT_NUMBER/locations/global/backendServices/tcp-helloworld-service
  matches:
  - address: '10.0.0.1/32'
    port: '10000'

Crea el recurso TcpRoute con la especificación de tcp_route.yaml.

gcloud network-services tcp-routes import helloworld-tcp-route \
  --source=tcp-route.yaml \
  --location=global

Crea un cliente de TCP con un sidecar de Envoy

Crea una plantilla de instancias y, luego, crea una VM con Envoy que esté conectada a Cloud Service Mesh.

gcloud beta compute instance-templates create td-vm-client-template \
  --image-family=debian-10 \
  --image-project=debian-cloud \
  --service-proxy=enabled,mesh=sidecar-mesh \
  --metadata=startup-script="#! /bin/bash
sudo apt-get update -y
sudo apt-get install netcat -y"

gcloud compute instances create td-vm-client \
  --zone=ZONE \
  --source-instance-template td-vm-client-template

Accede a la VM que creaste.
```
gcloud compute ssh td-vm-client
```
Verifica la conectividad a los servicios de prueba que creaste mediante la utilidad netcat.
```
echo 'Hi TCP Service' | nc 10.0.0.1 10000
```

El servicio de prueba debe mostrar la frase Hello from TCP service. También deberías poder ver cualquier texto que escribas, mostrado por el servicio netcat que se ejecuta en la VM remota.

¿Qué sigue?

Para obtener información sobre cómo mostrar una lista de recursos de ruta asociados con una Mesh o Recurso Gateway, consulta Lista de recursos Route. Esta función está en vista previa.