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

Invocar un extremo privado que cumpla con los Controles del servicio de VPC

Puedes seleccionar un extremo privado para las llamadas HTTP desde la ejecución del flujo de trabajo. Para ello, haz lo siguiente: usando el registro de servicios del Directorio de servicios con Workflows. Con la creación de un extremo privado en una red de nube privada virtual (VPC), el extremo puede ser compatible con los Controles del servicio de VPC.

Los Controles del servicio de VPC proporcionan una capa adicional en la defensa de seguridad que se independiente de Identity and Access Management (IAM). Si bien IAM habilita control de acceso basado en la identidad detallado, los Controles del servicio de VPC permiten seguridad perimetral basada en contexto, que incluye el control de salida de datos en el perímetro de servicio.

El Directorio de servicios es un el registro de servicio que almacena información sobre los servicios de red registrados incluidos sus nombres, ubicaciones y atributos. Independientemente de su puedes registrar servicios automáticamente y capturar su más detalles. Esto te permite descubrir, publicar y conectar servicios a gran escala para a todos los extremos de tu servicio.
Una red de VPC proporciona conectividad para tus instancias de máquina virtual (VM) y te permite crear extremos privados en tu red de VPC con direcciones IP internas. HTTP Las llamadas a un recurso de red de VPC se envían a través de una red privada y aplicar Controles del servicio de VPC y IAM.
Los Controles del servicio de VPC son una función de Google Cloud que permite configurar un perímetro de servicio y crear un límite de transferencia de datos. Puedes usar los Controles del servicio de VPC con Workflows para proteger tus servicios y reducir el riesgo de robo de datos.

En este documento, se muestra cómo registrar una VM en una red de VPC como un extremo del Directorio de servicios. Esto te permite proporcionar tu flujo de trabajo con un nombre de servicio del Directorio de servicios. Tu la ejecución del flujo de trabajo usa la información recuperada del registro de servicio para enviar la solicitud HTTP adecuada sin salir a una red pública.

En este diagrama, se proporciona una descripción general:

Envía una solicitud HTTP a un número de puerto en una instancia de VM con información del Directorio de servicios

En un nivel alto, debes seguir los siguientes pasos:

Otorga permisos al agente de servicio de Cloud Workflows para que el agente de servicio pueda visualizar los recursos del Directorio de servicios y acceder a las redes de VPC con el Directorio de servicios.
Crea una red de VPC para proporcionar las funciones de red.
Crea una regla de firewall de VPC para que puede permitir o denegar el tráfico hacia o desde las instancias de VM en tu VPC, en cada red.
Crea una instancia de VM en la red de VPC. R Una instancia de VM de Compute Engine es una máquina virtual alojada en la infraestructura de Google. Los términos instancia de Compute Engine, Instancia de VM y VM son sinónimos y se usan indistintamente.
Implementa una aplicación en la VM. Puedes ejecutar una app en tu instancia de VM y confirmar que el tráfico se entrega según lo esperado.
Configura el Directorio de servicios para que la ejecución del flujo de trabajo pueda invocar un Directorio de servicios extremo.
Crea e implementa tu flujo de trabajo. El private_service_name en tu flujo de trabajo especifica la extremo del Directorio de servicios que registraste en paso.

Otorga permisos al agente de servicio de Cloud Workflows

Algunos servicios de Google Cloud tienen Los agentes de servicio que permiten que los servicios accedan tus recursos. Si una API requiere un agente de servicio, Google crea el agente de servicio después de que activas y usas la API.

Cuando implementas un flujo de trabajo por primera vez, el agente de servicio de Cloud Workflows se crea automáticamente el siguiente formato:

service-PROJECT_NUMBER@gcp-sa-workflows.iam.gserviceaccount.com

Puedes crear manualmente la cuenta de servicio en un proyecto sin ninguna flujos de trabajo con el siguiente comando:
```
gcloud beta services identity create \
    --service=workflows.googleapis.com \
    --project=PROJECT_ID
```
Reemplaza PROJECT_ID por el ID del proyecto de Google Cloud.
Para ver los recursos del Directorio de servicios, otorga el permiso Función de visualizador del Directorio de servicios (servicedirectory.viewer) en el proyecto a Workflows agente de servicio:
```
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:service-PROJECT_NUMBER@gcp-sa-workflows.iam.gserviceaccount.com \
    --role=roles/servicedirectory.viewer
```
Reemplaza PROJECT_NUMBER por el número de proyecto de Google Cloud. Para encontrar el número del proyecto, ve a la página de bienvenida de la consola de Google Cloud o ejecuta el siguiente comando:
```
gcloud projects describe PROJECT_ID --format='value(projectNumber)'
```
Para acceder a las redes de VPC con el Directorio de servicios, otorga el Función de servicio autorizado de Private Service Connect (roles/servicedirectory.pscAuthorizedService) del proyecto al Agente de servicio de Workflows:
```
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:service-PROJECT_NUMBER@gcp-sa-workflows.iam.gserviceaccount.com \
    --role=roles/servicedirectory.pscAuthorizedService
```

Crear red de VPC

Una red de VPC es una versión virtual de una red física que se implementa en la red de producción de Google. Proporciona conectividad para las instancias de VM de Compute Engine.

Puedes crear un VPC de modo automático o personalizado en cada red. Cada red nueva que crees debe tener un nombre único dentro del mismo proyecto.

Por ejemplo, el siguiente comando crea una VPC de modo automático red:

gcloud compute networks create NETWORK_NAME \
    --subnet-mode=auto

Reemplaza NETWORK_NAME por un nombre para la red de VPC.

Para obtener más información, consulta Crea y administra redes de VPC.

Crea una regla de firewall de VPC

Con las reglas de firewall de VPC puedes permitir o denegar el tráfico hacia o desde la VM instancias en una red de VPC según el número de puerto, la etiqueta o protocolo.

Las reglas de firewall de VPC se definen a nivel de red y solo se aplican a la red en la que se crean; sin embargo, el nombre que elijas para una regla debe ser exclusivo del proyecto.

Por ejemplo, el siguiente comando crea una regla de firewall para un red de VPC y permite el tráfico de entrada desde cualquier dirección IPv4. 0.0.0.0/0. El valor de la marca --rules de all hace que la regla sea aplicable a todas y a todos los puertos de destino.

gcloud compute firewall-rules create RULE_NAME \
    --network=projects/PROJECT_ID/global/networks/NETWORK_NAME \
    --direction=INGRESS \
    --action=ALLOW \
    --source-ranges=0.0.0.0/0 \
    --rules=all

Reemplaza RULE_NAME por un nombre para la regla de firewall.

Para obtener más información, consulta Reglas de firewall de VPC.

Crea una instancia de VM en la red de VPC

Las instancias de VM incluyen clústeres de Google Kubernetes Engine (GKE), App Engine las instancias de entorno flexible y otros productos de Google Cloud basados en VMs de Compute Engine. Para brindar asistencia acceso a redes privadas, un recurso de red de VPC puede ser una instancia de VM una dirección IP de Cloud Interconnect o un balanceador de cargas interno de capa 4.

Las instancias de Compute Engine pueden ejecutar imágenes públicas para Linux y Windows que proporciona Google, así como imágenes privadas personalizadas que puedas crear o importar desde tus sistemas existentes. También puedes implementar Docker contenedores.

Puedes elegir las propiedades de máquina de tus instancias, como la cantidad de CPU virtuales y la cantidad de memoria, ya sea usando un conjunto de o creando tus propios tipos personalizados de máquinas.

Por ejemplo, el siguiente comando crea una instancia de VM de Linux a partir de una red con una interfaz de red conectada a la red de VPC a la que creados previamente.

Crea y, luego, inicia una instancia de VM:

gcloud compute instances create VM_NAME \
    --image-family=debian-11 \
    --image-project=debian-cloud \
    --machine-type=e2-micro \
    --network-interface network=projects/PROJECT_ID/global/networks/NETWORK_NAME

Reemplaza VM_NAME por un nombre para la VM.

Si se te solicita que confirmes la zona de la instancia, escribe y.

Después de crear la instancia de VM, toma nota de la dirección INTERNAL_IP que se devuelve.
En la consola de Google Cloud, ve a la página Instancias de VM.

Ir a Instancias de VM
En la columna Nombre, haz clic en el nombre de la instancia de VM correspondiente.
Si la VM está en ejecución, haz clic en Detener.
Para editar la VM, haz clic en Editar.
En la sección Herramientas de redes > Firewalls, para permitir HTTP o Tráfico HTTPS a la VM, selecciona Permitir tráfico HTTP o Permitir tráfico HTTPS

Para este ejemplo, selecciona la casilla de verificación Permitir tráfico HTTP.

Compute Engine agrega una etiqueta de red a tu VM que asocia la regla de firewall con la VM. Luego, crea el firewall de entrada correspondiente que permite todo el tráfico entrante en tcp:80 (HTTP) o tcp:443 (HTTPS).
Para guardar los cambios, haz clic en Guardar.
Para reiniciar la VM, haz clic en Iniciar/Reanudar.

Para obtener más información, consulta Crea y, luego, inicia una instancia de VM.

Implementa una aplicación en la VM

Para probar la configuración de red y confirmar que el tráfico se entrega como puedes implementar una app simple en tu VM que escuche en un puerto.

Por ejemplo, los siguientes comandos crean un servicio web de Node.js que escucha el puerto 3000.

Establece una conexión SSH a tu VM instancia.
Actualiza los repositorios de tus paquetes:
```
sudo apt update
```
Instala NVM. Node.js, y npm.

Para obtener más información, consulta Configura un entorno de desarrollo de Node.js.

Crea un archivo package.json de forma interactiva:

npm init

Por ejemplo:

{
"name": "test",
"version": "1.0.0",
"description": "",
"main": "index.js",
"scripts": {
"test": "hello"
},
"author": "",
"license": "ISC"
}

Instala Express, una aplicación web para Node.js:
```
npm install express
```
Escribe el código para la app de prueba:
```
vim app.js
```
En el siguiente ejemplo, se crea una app que responde a las solicitudes GET al ruta raíz (/) con el texto "Hello, world!"
```
const express = require('express');
const app = express();

app.get('/', (req, res) => {
  res.status(200).send('Hello, world!').end();
});

app.listen(3000, () => {
  console.log('Sample app listening on port 3000.');
});
```
Toma nota del puerto en el que escucha la app. Se debe usar el mismo número de puerto cuando configures el extremo del Directorio de servicios servicio.
Confirma que la app esté escuchando en el puerto 3000:
```
node app.js
```

Compute Engine ofrece una variedad de opciones de implementación. Para ver más información, consulta Elige una estrategia de implementación de Compute Engine para tu carga de trabajo.

Configura el Directorio de servicios

Para admitir la invocación de un extremo privado desde la ejecución de un flujo de trabajo, debes establecer un espacio de nombres del Directorio de servicios, registrar un servicio de Terraform y agrega un extremo al servicio.

Por ejemplo, los siguientes comandos crean un espacio de nombres, un servicio y un extremo que especifica la red de VPC y la IP interna de tu instancia de VM.

Crea un espacio de nombres:
```
gcloud service-directory namespaces create NAMESPACE \
    --location=REGION
```
Reemplaza lo siguiente:
- NAMESPACE: Es el ID del espacio de nombres o un identificador calificado para el espacio de nombres.
- REGION: Es la región de Google Cloud que contiene el espacio de nombres; por ejemplo, us-central1.

Crea un servicio:

gcloud service-directory services create SERVICE \
    --namespace=NAMESPACE \
    --location=REGION

Reemplaza SERVICE por el nombre del servicio. están creando.

Configurar un extremo

Nota: Asegúrate de configurar solo un extremo por Directorio de servicios servicio. Si se configura más de un extremo, Workflows elige un extremo de forma arbitraria.
```
gcloud service-directory endpoints create ENDPOINT \
    --namespace=NAMESPACE \
    --service=SERVICE \
    --network=projects/PROJECT_NUMBER/locations/global/networks/NETWORK_NAME \
    --port=PORT_NUMBER \
    --address=IP_ADDRESS \
    --location=REGION
```
Reemplaza lo siguiente:
- ENDPOINT: Es el nombre del extremo que deseas. creando.
- PORT_NUMBER: Es el puerto en el que se ejecuta el extremo. activado; por ejemplo, 3000.
- IP_ADDRESS: Es la dirección IPv6 o IPv4 del extremo. Esta es la dirección IP interna que anotaste antes.

Para obtener más información, consulta Configura el Directorio de servicios y Configurar el acceso a la red privada.

Crea e implementa tu flujo de trabajo

Se realiza la llamada o la invocación de un extremo privado desde Workflows a través de una solicitud HTTP. Los métodos de solicitud HTTP más comunes tienen una llamada (como http.get y http.post), pero puedes hacer que cualquier tipo de solicitud HTTP configurando el campo call como http.request y y especifica el tipo de solicitud con el campo method. Para obtener más información, consulta Realiza una solicitud HTTP.

Crea un archivo de código fuente para tu flujo de trabajo:
```
touch call-private-endpoint.JSON_OR_YAML
```
Reemplaza JSON_OR_YAML por yaml o json. según el formato de tu flujo de trabajo.

En un editor de texto, copia el siguiente flujo de trabajo (que en este caso usa un protocolo HTTP para el valor url) al archivo de código fuente:

YAML

main:
  steps:
    - checkHttp:
        call: http.get
        args:
          url: http://IP_ADDRESS
          private_service_name: "projects/PROJECT_ID/locations/REGION/namespaces/NAMESPACE/services/SERVICE"
        result: res
    - ret:
        return: ${res}

JSON

{
  "main": {
    "steps": [
      {
        "checkHttp": {
          "call": "http.get",
          "args": {
            "url": "http://IP_ADDRESS",
            "private_service_name": "projects/PROJECT_ID/locations/REGION/namespaces/NAMESPACE/services/SERVICE"
          },
          "result": "res"
        }
      },
      {
        "ret": {
          "return": "${res}"
        }
      }
    ]
  }
}

El valor private_service_name debe ser una cadena que especifique un nombre del servicio registrado del Directorio de servicios con el con el siguiente formato:

projects/PROJECT_ID/locations/LOCATION/namespaces/NAMESPACE_NAME/services/SERVICE_NAME

Implementar el flujo de trabajo Para realizar pruebas, puedes adjuntar el archivo Compute Engine cuenta de servicio predeterminada al flujo de trabajo para representar su identidad:
```
gcloud workflows deploy call-private-endpoint \
    --source=call-private-endpoint.JSON_OR_YAML \
    --location=REGION \
    --service-account=PROJECT_NUMBER-compute@developer.gserviceaccount.com
```
Precaución: Recomendamos que uses la configuración predeterminada de Compute Engine la cuenta de servicio solo para realizar pruebas. Para los entornos de producción, recomendamos especialmente crear una cuenta de servicio nueva y otorgarle uno o más roles de IAM que contengan la duración los permisos necesarios y seguir el principio de privilegio mínimo.

Ejecuta el flujo de trabajo:

gcloud workflows run call-private-endpoint \
    --location=REGION

Deberías ver un resultado similar al siguiente:

argument: 'null'
duration: 0.650784403s
endTime: '2023-06-09T18:19:52.570690079Z'
name: projects/968807934019/locations/us-central1/workflows/call-private-endpoint/executions/4aac88d3-0b54-419b-b364-b6eb973cc932
result: '{"body":"Hello, world!","code":200,"headers":{"Connection":"keep-alive","Content-Length":"21","Content-Type":"text/html;
charset=utf-8","Date":"Fri, 09 Jun 2023 18:19:52 GMT","Etag":"W/\"15-NFaeBgdti+9S7zm5kAdSuGJQm6Q\"","Keep-Alive":"timeout=5","X-Powered-By":"Express"}}'
startTime: '2023-06-09T18:19:51.919905676Z'
state: SUCCEEDED