Esta página foi traduzida pela API Cloud Translation.

Invocar um endpoint particular compatível com o VPC Service Controls

É possível segmentar um endpoint particular para chamadas HTTP a partir da execução do seu fluxo de trabalho usando o registro de serviços do Diretório de serviços com o Workflows. Ao criar um endpoint particular em uma rede de nuvem privada virtual (VPC), o endpoint possa ser compatível com o VPC Service Controls.

O VPC Service Controls adiciona uma camada extra de defesa de segurança que é independentes do Identity and Access Management (IAM). O IAM permite controle de acesso baseado em identidade granular, o VPC Service Controls permite uma abordagem segurança de perímetro baseada em contexto, incluindo o controle da saída de dados em toda a perímetro de serviço.

O Diretório de serviços é uma registro de serviço, que armazena informações sobre serviços de rede registrados, incluindo nomes, locais e atributos. Independentemente do Google, você pode registrar serviços automaticamente e capturar os detalhes. Isso permite que você descubra, publique e conecte serviços em escala para todos os endpoints de serviço.
Uma rede VPC fornece conectividade para as instâncias de máquina virtual (VM) e permite criar endpoints particulares na rede VPC usando endereços IP internos. HTTP chamadas para um recurso de rede VPC são enviadas por uma rede privada e aplicar o IAM e o VPC Service Controls.
O VPC Service Controls é uma recurso do Google Cloud que permite configurar um perímetro de serviço e criar um limite de transferência de dados. É possível usar o VPC Service Controls Workflows para ajudar a proteger seus serviços e reduzir o risco de exfiltração de dados.

Neste documento, mostramos como registrar uma VM em uma rede VPC como um endpoint do Diretório de serviços. Assim, você pode fornecer seu fluxo de trabalho com um nome de serviço do Diretório de serviços. Seu A execução do fluxo de trabalho usa as informações recuperadas do registro de serviço para enviar a solicitação HTTP adequada sem sair para uma rede pública.

Este diagrama mostra uma visão geral:

Enviar uma solicitação HTTP para um número de porta em uma instância de VM usando informações do Diretório de serviços

Em geral, você precisa fazer o seguinte:

Conceder permissões ao agente de serviço do Cloud Workflows para que o agente de serviço possa visualizar os recursos do Diretório de serviços e acessar redes VPC usando o Diretório de serviços.
Crie uma rede VPC para fornecer funcionalidade de rede.
Crie uma regra de firewall de VPC pode permitir ou negar tráfego de ou para instâncias de VM na sua VPC em uma rede VPC.
Crie uma instância de VM na rede VPC. Um A instância de VM do Compute Engine é uma máquina virtual hospedada em do Google. Os termos instância do Compute Engine Instância de VM e VM são sinônimos e são usados de maneira intercambiável.
Implantar um aplicativo na VM. É possível executar um app no seu instância da VM e confirme se o tráfego está sendo exibido conforme o esperado.
Configurar o Diretório de serviços para que a execução do fluxo de trabalho possa invocar um diretório de serviços endpoint do Google Cloud.
Crie e implante seu fluxo de trabalho. O O valor private_service_name no seu fluxo de trabalho especifica Endpoint do Diretório de serviços que você registrou no etapa.

Conceder permissões ao agente de serviço do Cloud Workflows

Alguns serviços do Google Cloud têm agentes de serviços que permitem que os serviços acessem seus recursos. Se uma API exigir um agente de serviço, o Google criará esse agente depois que você ativar e começar a usar a API.

Ao implantar um fluxo de trabalho pela primeira vez, o agente de serviço do Cloud Workflows é criado automaticamente com o seguinte formato:

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

É possível criar manualmente a conta de serviço em um projeto sem fluxos de trabalho com este comando:
```
gcloud beta services identity create \
    --service=workflows.googleapis.com \
    --project=PROJECT_ID
```
Substitua o PROJECT_ID pelo ID do projeto do Google Cloud.
Para acessar os recursos do Diretório de serviços, conceda Papel de Leitor do Diretório de serviços (servicedirectory.viewer) no projeto para o Workflows agente de serviço:
```
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:service-PROJECT_NUMBER@gcp-sa-workflows.iam.gserviceaccount.com \
    --role=roles/servicedirectory.viewer
```
Substitua PROJECT_NUMBER pelo número do projeto do Google Cloud. Encontre o número do projeto na página Boas-vindas do console do Google Cloud ou executando o seguinte comando:
```
gcloud projects describe PROJECT_ID --format='value(projectNumber)'
```
Para acessar redes VPC usando o Diretório de serviços, conceder Papel de serviço autorizado do Private Service Connect (roles/servicedirectory.pscAuthorizedService) no projeto para a Agente de serviço do Workflows:
```
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:service-PROJECT_NUMBER@gcp-sa-workflows.iam.gserviceaccount.com \
    --role=roles/servicedirectory.pscAuthorizedService
```

Crie uma rede VPC

Uma rede VPC é uma versão virtual de uma rede física, implementada dentro da rede de produção do Google Ela fornece conectividade para suas instâncias de VM do Compute Engine.

É possível criar um VPC de modo automático ou personalizado em uma rede VPC. Cada nova rede criada deve ter um nome exclusivo no no mesmo projeto.

Por exemplo, o comando a seguir cria uma VPC de modo automático rede:

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

Substitua NETWORK_NAME por um nome para a rede VPC.

Para mais informações, consulte Criar e gerenciar redes VPC.

Criar uma regra de firewall de VPC

Com as regras de firewall da VPC, é possível permitir ou negar o tráfego de entrada ou saída de VMs em uma rede VPC com base no número da porta, tag ou protocolo.

As regras de firewall são identificadas no nível da rede e se aplicam apenas à rede em que são criadas. No entanto, o nome escolhido para cada regra precisa ser único no projeto.

Por exemplo, o comando a seguir cria uma regra de firewall para um determinado rede VPC e permite tráfego de entrada de qualquer endereço IPv4, 0.0.0.0/0: O valor da flag --rules de all torna a regra aplicável a todos protocolos e todas as portas 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

Substitua RULE_NAME por um nome para a regra de firewall.

Para mais informações, consulte Usar regras de firewall da VPC.

Criar uma instância de VM na rede VPC

As instâncias de VM incluem clusters do Google Kubernetes Engine (GKE), do ambiente flexível e de outros produtos do Google Cloud criados em VMs do Compute Engine. Para o suporte acesso a redes privadas, um recurso de rede VPC pode ser uma instância de VM, endereço IP do Cloud Interconnect ou de um balanceador de carga interno de camada 4.

As instâncias do Compute Engine podem executar imagens públicas para Linux e Windows do Google, bem como imagens particulares personalizadas que você pode criar ou importar de sistemas existentes. Também é possível implantar o Docker containers.

Escolha as propriedades de máquina das instâncias, como o número de CPUs virtuais e a quantidade de memória com o uso de um conjunto de ou criando seus próprios tipos personalizados.

Por exemplo, o comando a seguir cria uma instância de VM do Linux usando uma com uma interface de rede anexada à rede VPC que você criados anteriormente.

Crie e inicie uma instância 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

Substitua VM_NAME por um nome para a VM.

Se você precisar confirmar a zona da instância, digite y.

Depois de criar a instância de VM, anote o endereço INTERNAL_IP retornado.
No console do Google Cloud, acesse a página Instâncias de VMs.

Acessar instâncias de VM
Na coluna Nome, clique no nome da instância de VM apropriada.
Se a VM estiver em execução, clique em Parar.
Para editar a VM, clique em Editar.
Na seção Rede > Firewalls, para permitir HTTP ou tráfego HTTPS para a VM, selecione Permitir tráfego HTTP ou Permitir tráfego HTTPS.

Neste exemplo, marque a caixa de seleção Permitir tráfego HTTP.

O Compute Engine adiciona uma tag de rede à VM que associa os de firewall com a VM. Em seguida, ele cria o firewall de entrada que permite todo o tráfego de entrada em tcp:80 (HTTP) ou tcp:443 (HTTPS).
Para salvar as alterações, clique em Save.
Para reiniciar a VM, clique em Iniciar/Retomar.

Para mais informações, consulte Criar e iniciar uma instância de VM.

Implantar um aplicativo na VM

Para testar a configuração da rede e confirmar se o tráfego está sendo veiculado como esperado, é possível implantar na VM um app simples que detecta em uma porta.

Por exemplo, os comandos a seguir criam um serviço da Web Node.js que detecta na porta 3000.

Estabelecer uma conexão SSH com a VM instância.
Atualize os repositórios de pacotes:
```
sudo apt update
```
Instale o NVM Node.js, e NPM.

Para mais informações, consulte Como configurar um ambiente de desenvolvimento em Node.js.

Crie um arquivo package.json interativamente:

npm init

Exemplo:

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

Instale o Express, um aplicativo da Web para Node.js:
```
npm install express
```
Crie o código do app de teste:
```
vim app.js
```
O exemplo a seguir cria um aplicativo que responde a solicitações GET para o caminho raiz (/) com o 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.');
});
```
Observe a porta em que o app está escutando. O mesmo número de porta precisa ser usado ao configurar o endpoint para o Diretório de serviços serviço.
Confirme se o aplicativo está escutando na porta 3000:
```
node app.js
```

O Compute Engine oferece várias opções de implantação. Para mais informações, consulte Escolha uma estratégia de implantação do Compute Engine para sua carga de trabalho.

Configurar o Diretório de serviços

Para dar suporte à invocação de um endpoint particular a partir de uma execução de fluxo de trabalho, defina um namespace do Diretório de serviços, registrar um serviço no e adicionar um endpoint ao serviço.

Por exemplo, os comandos a seguir criam um namespace, um serviço e um endpoint que especifica a rede VPC e o IP interno da instância de VM.

Para criar um namespace:
```
gcloud service-directory namespaces create NAMESPACE \
    --location=REGION
```
Substitua:
- NAMESPACE: o ID do namespace ou identificador qualificado para o namespace.
- REGION: a região do Google Cloud que contém o namespace; por exemplo, us-central1.

Crie um serviço:

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

Substitua SERVICE pelo nome do serviço que você estão criando.

Configurar um endpoint

Observação: configure apenas um endpoint por Diretório de serviços serviço. Se mais de um endpoint for configurado, Workflows escolhe arbitrariamente um endpoint.
```
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
```
Substitua:
- ENDPOINT: o nome do endpoint em que você está. criar.
- PORT_NUMBER: a porta em que o endpoint está em execução. por exemplo, 3000.
- IP_ADDRESS: o endereço IPv6 ou IPv4 do endpoint. esse é o endereço IP interno que você anotou anteriormente.

Para mais informações, consulte Configurar o Diretório de serviços e Configurar o acesso à rede privada.

Criar e implantar seu fluxo de trabalho

A chamada ou invocação de um endpoint particular do Workflows foi concluída por uma solicitação HTTP. Os métodos de solicitação HTTP mais comuns têm uma chamada atalho (como http.get e http.post), mas é possível fazer qualquer de solicitação HTTP definindo o campo call como http.request e especificando o tipo de solicitação usando o campo method. Para mais informações, consulte Fazer uma solicitação HTTP.

Crie um arquivo de código-fonte para seu fluxo de trabalho:
```
touch call-private-endpoint.JSON_OR_YAML
```
Substitua JSON_OR_YAML por yaml ou json. dependendo do formato do seu fluxo de trabalho.

Em um editor de texto, copie o fluxo de trabalho a seguir (que neste caso usa uma protocolo HTTP para o valor url) para seu arquivo de código-fonte:

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}"
        }
      }
    ]
  }
}

O valor private_service_name precisa ser uma string que especifica um nome de serviço registrado no Diretório de serviços formato:

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

Implantar o fluxo de trabalho. Para fins de teste, anexe Compute Engine conta de serviço padrão ao fluxo de trabalho para representar a identidade dele:
```
gcloud workflows deploy call-private-endpoint \
    --source=call-private-endpoint.JSON_OR_YAML \
    --location=REGION \
    --service-account=PROJECT_NUMBER-compute@developer.gserviceaccount.com
```
Cuidado: recomendamos o uso do padrão do Compute Engine conta de serviço apenas para fins de teste. Para ambientes de produção, é altamente recomendável Como criar uma nova conta de serviço e conceder a ele um ou mais papéis do IAM que contenham o mínimo as permissões necessárias e seguem o princípio do privilégio mínimo.

Execute o fluxo de trabalho:

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

Um resultado semelhante a este será exibido:

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