Invocar um ponto final privado através do registo de serviços do Service Directory

Pode segmentar um ponto final privado para chamadas HTTP a partir da execução do fluxo de trabalho usando o registo de serviços do Service Directory com os Workflows. Isto permite-lhe fornecer ao seu fluxo de trabalho um nome de serviço do diretório de serviços. A execução do fluxo de trabalho usa as informações obtidas do registo de serviços para enviar o pedido HTTP adequado, sem sair para uma rede pública.

Este documento mostra como registar uma máquina virtual (VM) numa rede da nuvem virtual privada (VPC) como um ponto final do Service Directory:

  • Uma rede VPC oferece conetividade para as suas instâncias de VM e permite-lhe criar pontos finais privados na sua rede VPC através de endereços IP internos. As chamadas HTTP para um recurso de rede VPC são enviadas através de uma rede privada enquanto aplicam a gestão de identidade e acesso (IAM) e os VPC Service Controls.

  • O diretório de serviços é um registo de serviços que armazena informações sobre os serviços de rede registados, incluindo os respetivos nomes, localizações e atributos. Independentemente da respetiva infraestrutura, pode registar serviços automaticamente e captar os respetivos detalhes. Isto permite-lhe descobrir, publicar e associar serviços em grande escala para todos os seus pontos finais de serviço.

Este diagrama oferece uma vista geral:

Enviar um pedido HTTP para um número de porta numa instância de VM através de informações do Service Directory

A um nível elevado, tem de fazer o seguinte:

  1. Conceda autorizações ao agente de serviço do Cloud Workflows para que o agente de serviço possa ver os recursos do Service Directory e aceder às redes VPC através do Service Directory.
  2. Crie uma rede VPC para fornecer funcionalidade de rede.
  3. Crie uma regra de firewall da VPC para poder permitir ou negar tráfego de ou para instâncias de VM na sua rede de VPC.
  4. Crie uma instância de VM na rede VPC. Uma instância de VM do Compute Engine é uma máquina virtual alojada na infraestrutura da Google. Os termos instância do Compute Engine, instância de VM e VM são sinónimos e são usados de forma intercambiável.
  5. Implemente uma aplicação na VM. Pode executar uma app na instância de VM e confirmar que o tráfego está a ser publicado conforme esperado.

  6. Configure o Service Directory para que a execução do fluxo de trabalho possa invocar um ponto final do Service Directory.

  7. Crie e implemente o seu fluxo de trabalho. O valor private_service_name no seu fluxo de trabalho especifica o ponto final do diretório de serviços que registou no passo anterior.

Conceda autorizações ao agente de serviço do Cloud Workflows

Alguns Google Cloud serviços têm agentes de serviço que permitem aos serviços aceder aos seus recursos. Se uma API exigir um agente de serviço, a Google cria o agente de serviço depois de ativar e usar a API.

  1. Quando implementa um fluxo de trabalho pela primeira vez, o agente do serviço Cloud Workflows é criado automaticamente com o seguinte formato:

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

    Pode criar manualmente a conta de serviço num projeto sem fluxos de trabalho com este comando:

    gcloud beta services identity create \
    --service=workflows.googleapis.com \
    --project=PROJECT_ID

    Substitua PROJECT_ID pelo seu Google Cloud ID do projeto.

  2. Para ver os recursos do Service Directory, conceda a função Leitor do Service Directory (servicedirectory.viewer) no projeto ao 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.viewer

    Substitua PROJECT_NUMBER pelo seu Google Cloud número do projeto. Pode encontrar o número do projeto na página Boas-vindas da Google Cloud consola ou executando o seguinte comando:

    gcloud projects describe PROJECT_ID --format='value(projectNumber)'

  3. Para aceder às redes VPC através do Service Directory, conceda a função de serviço autorizado do Private Service Connect (roles/servicedirectory.pscAuthorizedService) no projeto ao agente do serviço 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 de VPC

Uma rede VPC é uma versão virtual de uma rede física que é implementada na rede de produção da Google. Fornece conetividade para as suas instâncias de VM do Compute Engine.

Pode criar uma rede VPC no modo automático ou no modo personalizado. Cada nova rede que criar tem de ter um nome exclusivo no mesmo projeto.

Por exemplo, o comando seguinte cria uma rede VPC no modo automático:

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

Substitua NETWORK_NAME por um nome para a rede VPC.

Para mais informações, consulte o artigo Crie e faça a gestão de redes VPC.

Crie uma regra de firewall da VPC

As regras de firewall da VPC permitem-lhe autorizar ou negar tráfego para ou a partir de instâncias de VMs numa rede da VPC com base no número da porta, na etiqueta ou no protocolo.

As regras de firewall de VPC são definidas ao nível da rede e aplicam-se apenas à rede onde são criadas. No entanto, o nome que escolher para uma regra tem de ser exclusivo do projeto.

Por exemplo, o comando seguinte cria uma regra de firewall para a rede da VPC que criou anteriormente.

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

Substitua o seguinte:

  • RULE_NAME: um nome para a regra de firewall.

  • IP_ADDRESS_RANGE: um ou mais intervalos de endereços IPv4 ou IPv6. Como prática recomendada, especifique os intervalos de endereços IP específicos necessários para permitir o acesso. Tenha em conta o seguinte:

    • O acesso à rede privada para o Service Directory usa 35.199.192.0/19 como um intervalo apenas interno com saltos seguintes que estão totalmente dentro da rede da Google. Para mais informações, consulte o artigo Caminhos para o Cloud DNS e o Service Directory.

    • A inclusão de 35.235.240.0/20 nos intervalos de origem permite ligações SSH através do encaminhamento TCP do Identity-Aware Proxy (IAP) se todos os outros pré-requisitos forem cumpridos. Para mais informações, consulte o artigo Usar o IAP para encaminhamento TCP.

    • Se estiver a usar a ferramenta SSH no navegador para estabelecer ligação à sua VM do Compute Engine a partir da Google Cloud consola, existem requisitos específicos.

  • O valor da flag --rules de all torna a regra de firewall aplicável a todos os protocolos e a todas as portas de destino. Pode restringir o âmbito especificando protocolos e portas.

  • Opcionalmente, pode usar as flags --target-tags e --target-service-accounts para definir segmentações; caso contrário, a regra aplica-se a todas as segmentações na rede.

Para mais informações, consulte o artigo Use regras da firewall da VPC.

Crie uma instância de VM na rede VPC

As instâncias de VMs incluem clusters do Google Kubernetes Engine (GKE), instâncias do ambiente flexível do App Engine e outros Google Cloud produtos criados com base em Google Cloud VMs do Compute Engine. Para suportar o acesso à rede privada, um recurso de rede VPC pode ser uma instância de VM, um endereço IP do Cloud Interconnect ou um equilibrador de carga interno da camada 4.

As instâncias do Compute Engine podem executar imagens públicas para Linux e Windows Server fornecidas pela Google, bem como imagens personalizadas privadas que pode criar ou importar dos seus sistemas existentes. Também pode implementar contentores do Docker.

Pode escolher as propriedades da máquina das suas instâncias, como o número de CPUs virtuais e a quantidade de memória, usando um conjunto de tipos de máquinas predefinidos ou criando os seus próprios tipos de máquinas personalizados.

Por exemplo, o comando seguinte cria uma instância de VM do Linux a partir de uma imagem pública com uma interface de rede anexada à rede de VPC que criou anteriormente.

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

  2. Se lhe for pedido que confirme a zona da instância, escreva y.

    Depois de criar a instância de VM, tome nota do endereço INTERNAL_IP que é devolvido.

  3. Na Google Cloud consola, aceda à página Instâncias de VM.

    Aceder às instâncias de VM

  4. Na coluna Nome, clique no nome da instância de VM adequada.

  5. Se a VM estiver em execução, para a parar, clique em Parar.

  6. Para editar a VM, clique em Editar.

  7. Na secção Rede > Firewalls, para permitir o tráfego HTTP ou HTTPS para a VM, selecione Permitir tráfego HTTP ou Permitir tráfego HTTPS.

    Para este exemplo, selecione a caixa de verificação Permitir tráfego HTTP.

    O Compute Engine adiciona uma etiqueta de rede à sua VM que associa a regra de firewall à VM. Em seguida, cria a regra de firewall de entrada correspondente que permite todo o tráfego recebido em tcp:80 (HTTP) ou tcp:443 (HTTPS).

  8. Para guardar as alterações, clique em Guardar.

  9. Para reiniciar a VM, clique em Iniciar/Retomar.

Para mais informações, consulte o artigo Crie e inicie uma instância de VM.

Implemente uma aplicação na VM

Para testar a configuração de rede e confirmar que o tráfego está a ser publicado conforme esperado, pode implementar uma app básica na sua VM que escute numa porta.

Por exemplo, os comandos seguintes criam um serviço Web Node.js que escuta na porta 3000.

  1. Estabeleça uma ligação SSH à instância da VM.

  2. Atualize os repositórios de pacotes:

    sudo apt update

  3. Instale o NVM, Node.js e npm.

    Para mais informações, consulte o artigo Configurar um ambiente de desenvolvimento do Node.js.

  4. Crie um ficheiro package.json interativamente:

    npm init

    Por exemplo:

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

  5. Instale o Express, uma framework de apps Web para o Node.js:

    npm install express

  6. Escreva o código para a app de teste:

    vim app.js

    O exemplo seguinte cria uma app que responde a pedidos GET para o caminho raiz (/) com o texto "Olá, mundo!"

    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.');
});

    Tome nota da porta na qual a app está a ouvir. Tem de usar o mesmo número da porta quando configurar o ponto final para o serviço do diretório de serviços.

  7. Confirme se a app está a ouvir na porta 3000:

    node app.js

O Compute Engine oferece uma variedade de opções de implementação. Para mais informações, consulte o artigo Escolha uma estratégia de implementação do Compute Engine para a sua carga de trabalho.

Configure o Service Directory

Para suportar a invocação de um ponto final privado a partir da execução de um fluxo de trabalho, tem de configurar um espaço de nomes do Service Directory, registar um serviço no espaço de nomes e adicionar um ponto final ao serviço.

Por exemplo, os seguintes comandos criam um espaço de nomes, um serviço e um ponto final que especifica a rede VPC e o endereço IP interno da sua instância de VM.

  1. Crie um espaço de nomes:

    gcloud service-directory namespaces create NAMESPACE \
    --location=REGION

    Substitua o seguinte:

    • NAMESPACE: o ID do espaço de nomes ou o identificador totalmente qualificado do espaço de nomes.
    • REGION: a região que contém o espaço de nomes; por exemplo, us-central1. Google Cloud

  2. Crie um serviço:

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

    Substitua SERVICE pelo nome do serviço que está a criar.

  3. Configure um ponto final.

    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 o seguinte:

    • ENDPOINT: o nome do ponto final que está a criar.
    • PORT_NUMBER: a porta em que o ponto final está a ser executado; por exemplo, 3000.
    • IP_ADDRESS: o endereço IPv6 ou IPv4 do ponto final; este é o endereço IP interno que anotou anteriormente.

Para mais informações, consulte os artigos Configure o Service Directory e Configure o acesso à rede privada.

Crie e implemente o seu fluxo de trabalho

A chamada ou a invocação de um ponto final privado a partir dos fluxos de trabalho é feita através de um pedido HTTP. Os métodos de pedidos HTTP mais comuns têm um atalho de chamada (como http.get e http.post), mas pode fazer qualquer tipo de pedido HTTP definindo o campo call como http.request e especificando o tipo de pedido através do campo method. Para mais informações, consulte Faça um pedido HTTP.

  1. Crie um ficheiro de código-fonte para o seu fluxo de trabalho:

    touch call-private-endpoint.JSON_OR_YAML

    Substitua JSON_OR_YAML por yaml ou json, consoante o formato do seu fluxo de trabalho.

  2. Num editor de texto, copie o seguinte fluxo de trabalho (que, neste caso, usa um protocolo HTTP para o valor url) para o ficheiro 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 tem de ser uma string que especifique um nome de serviço do Service Directory registado com o seguinte formato:

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

  3. Implemente o fluxo de trabalho. Para fins de teste, pode anexar a conta de serviço predefinida do Compute Engine ao fluxo de trabalho para representar a respetiva identidade:

    gcloud workflows deploy call-private-endpoint \
    --source=call-private-endpoint.JSON_OR_YAML \
    --location=REGION \
    --service-account=PROJECT_NUMBER-compute@developer.gserviceaccount.com

  4. Execute o fluxo de trabalho:

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

    Deverá ver um resultado semelhante ao seguinte:

    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

O que se segue?