VPC Service Controls-kompatiblen privaten Endpunkt aufrufen

Sie können einen privaten Endpunkt für HTTP-Aufrufe von Ihrer Workflowausführung ansteuern. Verwenden Sie dazu die Dienst-Registry von Service Directory mit Workflows. Durch das Erstellen eines privaten Endpunkts in einem VPC-Netzwerk (Virtual Private Cloud) kann der Endpunkt VPC Service Controls-konform sein.

VPC Service Controls bietet eine zusätzliche Sicherheitsebene, die unabhängig von Identity and Access Management (IAM) ist. Während IAM eine detaillierte identitätsbasierte Zugriffssteuerung ermöglicht, ermöglicht VPC Service Controls eine breitere kontextbasierte Perimetersicherheit, einschließlich der Kontrolle ausgehender Daten im Perimeter.

Service Directory ist eine Dienst-Registry, die Informationen zu registrierten Netzwerkdiensten einschließlich ihrer Namen, Standorte und Attribute speichert. Unabhängig von ihrer Infrastruktur können Sie Dienste automatisch registrieren und deren Details erfassen. Auf diese Weise können Sie Dienste für alle Dienstendpunkte in großem Umfang erkennen, veröffentlichen und verbinden.
Ein VPC-Netzwerk stellt die Verbindung für Ihre VM-Instanzen bereit und ermöglicht Ihnen, mithilfe interner IP-Adressen private Endpunkte in Ihrem VPC-Netzwerk zu erstellen. HTTP-Aufrufe an eine VPC-Netzwerkressource werden über ein privates Netzwerk gesendet und dabei IAM und VPC Service Controls erzwungen.
VPC Service Controls ist ein Google Cloud-Feature, mit dem Sie einen Dienstperimeter einrichten und eine Datenübertragungsgrenze definieren können. Sie können VPC Service Controls mit Workflows verwenden, um Ihre Dienste zu schützen und das Risiko der Daten-Exfiltration zu verringern.

In diesem Dokument erfahren Sie, wie Sie eine VM in einem VPC-Netzwerk als Service Directory-Endpunkt registrieren. Auf diese Weise können Sie Ihrem Workflow einen Service Directory-Dienstnamen zur Verfügung stellen. Bei der Workflowausführung werden die aus der Dienst-Registry abgerufenen Informationen verwendet, um die entsprechende HTTP-Anfrage zu senden, ohne an ein öffentliches Netzwerk ausgehen zu müssen.

Dieses Diagramm bietet einen Überblick:

HTTP-Anfrage mit Informationen aus Service Directory an eine Portnummer auf einer VM-Instanz senden

Hier ist eine allgemeine Liste der erforderlichen Aufgaben:

Gewähren Sie dem Cloud Workflows-Dienst-Agent Berechtigungen, damit der Dienst-Agent Service Directory-Ressourcen ansehen und über Service Directory auf VPC-Netzwerke zugreifen kann.
Erstellen Sie ein VPC-Netzwerk, um Netzwerkfunktionen bereitzustellen.
Erstellen Sie eine VPC-Firewallregel, damit Sie Traffic zu oder von VM-Instanzen in Ihrem VPC-Netzwerk zulassen oder ablehnen können.
Erstellen Sie eine VM-Instanz im VPC-Netzwerk. Eine VM-Instanz von Compute Engine ist eine virtuelle Maschine, die in der Infrastruktur von Google gehostet wird. Die Begriffe Compute Engine-Instanz, VM-Instanz und VM sind Synonyme und werden synonym verwendet.
Anwendung auf der VM bereitstellen Sie können auf Ihrer VM-Instanz eine Anwendung ausführen und prüfen, ob der Traffic wie erwartet verarbeitet wird.
Konfigurieren Sie Service Directory so, dass die Workflowausführung einen Service Directory-Endpunkt aufrufen kann.
Workflow erstellen und bereitstellen Der Wert private_service_name im Workflow gibt den Service Directory-Endpunkt an, den Sie im vorherigen Schritt registriert haben.

Berechtigungen für den Cloud Workflows-Dienst-Agent gewähren

Einige Google Cloud-Dienste haben von Google verwaltete Dienstkonten, mit denen die Dienste auf Ihre Ressourcen zugreifen können. Diese Dienstkonten werden als Dienst-Agents bezeichnet. Wenn eine API einen Dienst-Agent erfordert, erstellt Google den Dienst-Agent, nachdem Sie die API aktiviert und verwendet haben.

Wenn Sie zum ersten Mal einen Workflow bereitstellen, wird der Cloud Workflows-Dienst-Agent automatisch im folgenden Format erstellt:

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

Mit diesem Befehl können Sie das Dienstkonto in einem Projekt ohne Workflows manuell erstellen:
```
gcloud beta services identity create \
    --service=workflows.googleapis.com \
    --project=PROJECT_ID
```
Ersetzen Sie PROJECT_ID durch die Google Cloud-Projekt-ID.
Weisen Sie dem Workflows-Dienst-Agent die Rolle Service Directory Viewer (servicedirectory.viewer) für das Projekt zu, um Service Directory-Ressourcen anzusehen:
```
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:service-PROJECT_NUMBER@gcp-sa-workflows.iam.gserviceaccount.com \
    --role=roles/servicedirectory.viewer
```
Ersetzen Sie PROJECT_NUMBER durch Ihre Google Cloud-Projektnummer. Sie finden Ihre Projektnummer auf der Willkommensseite der Google Cloud Console oder durch Ausführen des folgenden Befehls:
```
gcloud projects describe PROJECT_ID --format='value(projectNumber)'
```
Wenn Sie über Service Directory auf VPC-Netzwerke zugreifen möchten, gewähren Sie dem Workflows-Dienst-Agent die Rolle „Autorisierter Private Service Connect-Dienst“ (roles/servicedirectory.pscAuthorizedService) für das Projekt:
```
gcloud projects add-iam-policy-binding PROJECT_ID \
    --member=serviceAccount:service-PROJECT_NUMBER@gcp-sa-workflows.iam.gserviceaccount.com \
    --role=roles/servicedirectory.pscAuthorizedService
```

VPC-Netzwerk erstellen

Ein VPC-Netzwerk ist eine virtuelle Version eines physischen Netzwerks, die innerhalb des Produktionsnetzwerks von Google implementiert wurde. Sie ermöglicht eine Verbindung für Ihre Compute Engine-VM-Instanzen.

Sie können ein VPC-Netzwerk im automatischen oder benutzerdefinierten Modus erstellen. Jedes neu erstellte Netzwerk muss innerhalb desselben Projekts einen eindeutigen Namen haben.

Mit dem folgenden Befehl wird beispielsweise ein VPC-Netzwerk im automatischen Modus erstellt:

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

Ersetzen Sie NETWORK_NAME durch einen Namen für das VPC-Netzwerk.

Weitere Informationen finden Sie unter VPC-Netzwerke erstellen und verwalten.

VPC-Firewallregel erstellen

Mit VPC-Firewallregeln können Sie Traffic zu oder von VM-Instanzen in einem VPC-Netzwerk anhand der Portnummer, des Tags oder des Protokolls zulassen oder ablehnen.

VPC-Firewallregeln werden auf Netzwerkebene definiert und gelten nur für das Netzwerk, in dem sie erstellt werden. Der Name für jede Regel muss jedoch für das Projekt eindeutig sein.

Mit dem folgenden Befehl wird beispielsweise eine Firewallregel für ein angegebenes VPC-Netzwerk erstellt und eingehender Traffic von jeder IPv4-Adresse (0.0.0.0/0) zugelassen. Durch den Wert des Flags --rules von all wird die Regel auf alle Protokolle und Zielports angewendet.

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

Ersetzen Sie RULE_NAME durch einen Namen für die Firewallregel.

Weitere Informationen finden Sie unter VPC-Firewallregeln verwenden.

VM-Instanz im VPC-Netzwerk erstellen

VM-Instanzen umfassen Google Kubernetes Engine-Cluster (GKE), Instanzen der flexiblen App Engine-Umgebung und andere Google Cloud-Produkte, die auf Compute Engine-VMs basieren. Zur Unterstützung des privaten Netzwerkzugriffs kann eine VPC-Netzwerkressource eine VM-Instanz, eine Cloud Interconnect-IP-Adresse oder ein interner Layer-4-Load-Balancer sein.

Compute Engine-Instanzen können öffentliche Images für Linux und Windows Server ausführen, die Google bereitstellt, sowie private benutzerdefinierte Images, die Sie erstellen oder von Ihren vorhandenen Systemen importieren können. Sie können auch Docker-Container bereitstellen.

Sie können die Maschinenattribute Ihrer Instanzen auswählen, z. B. die Anzahl der virtuellen CPUs oder die Größe des Arbeitsspeichers, indem Sie vordefinierte Maschinentypen verwenden oder eigene benutzerdefinierte Maschinentypen erstellen.

Mit dem folgenden Befehl wird beispielsweise eine Linux-VM-Instanz aus einem öffentlichen Image mit einer Netzwerkschnittstelle erstellt, die an das zuvor erstellte VPC-Netzwerk angehängt ist.

Erstellen und starten Sie eine VM-Instanz:

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

Ersetzen Sie VM_NAME durch einen Namen für die VM.

Wenn Sie aufgefordert werden, die Zone für die Instanz zu bestätigen, geben Sie y ein.

Notieren Sie sich nach dem Erstellen der VM-Instanz die zurückgegebene INTERNAL_IP-Adresse.
Rufen Sie in der Google Cloud Console die Seite VM-Instanzen auf.

Zur Seite „VM-Instanzen“
Klicken Sie in der Spalte Name auf den Namen der entsprechenden VM-Instanz.
Wenn die VM ausgeführt wird, klicken Sie auf Beenden, um sie zu beenden.
Klicken Sie zum Bearbeiten der VM auf Bearbeiten.
Wählen Sie unter Netzwerk > Firewalls die Option HTTP-Traffic zulassen oder HTTPS-Traffic zulassen aus, um HTTP- oder HTTPS-Traffic zur VM zuzulassen.

Aktivieren Sie für dieses Beispiel das Kontrollkästchen HTTP-Traffic zulassen.

Compute Engine fügt der VM ein Netzwerk-Tag hinzu, mit dem die Firewallregel der VM zugeordnet wird. Anschließend wird die entsprechende Firewallregel für eingehenden Traffic erstellt, die den gesamten eingehenden Traffic über tcp:80 (HTTP) oder tcp:443 (HTTPS) zulässt.
Um die Änderungen zu speichern, klicken Sie auf Speichern.
Klicken Sie auf Starten/Fortsetzen, um die VM neu zu starten.

Weitere Informationen finden Sie unter VM-Instanz erstellen und starten.

Anwendung auf der VM bereitstellen

Sie können eine einfache Anwendung auf Ihrer VM bereitstellen, die einen Port überwacht, um die Netzwerkkonfiguration zu testen und zu bestätigen, dass der Traffic wie erwartet bereitgestellt wird.

Mit den folgenden Befehlen erstellen Sie beispielsweise einen Node.js-Webdienst, der Port 3000 überwacht.

Stellen Sie eine SSH-Verbindung zu Ihrer VM-Instanz her.
Aktualisieren Sie die Paket-Repositorys:
```
sudo apt update
```
Installieren Sie NVM, Node.js und npm.

Weitere Informationen finden Sie unter Node.js-Entwicklungsumgebung einrichten.

Erstellen Sie interaktiv eine package.json-Datei:

npm init

Beispiel:

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

Installieren Sie Express, ein Webanwendungs-Framework für Node.js:
```
npm install express
```
Schreiben Sie den Code für die Test-App:
```
vim app.js
```
Im folgenden Beispiel wird eine Anwendung erstellt, die auf GET-Anfragen an den Stammpfad (/) mit dem Text „Hello, world!“ antwortet.
```
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.');
});
```
Notieren Sie den Port, den die App überwacht. Wenn Sie den Endpunkt für den Service Directory-Dienst konfigurieren, muss dieselbe Portnummer verwendet werden.
Prüfen Sie, ob die App Port 3000 überwacht:
```
node app.js
```

Compute Engine bietet eine Reihe von Bereitstellungsoptionen. Weitere Informationen finden Sie unter Compute Engine-Bereitstellungsstrategie für Ihre Arbeitslast auswählen.

Service Directory konfigurieren

Damit ein privater Endpunkt aus einer Workflowausführung aufgerufen werden kann, müssen Sie einen Service Directory-Namespace einrichten, einen Dienst im Namespace registrieren und dem Dienst einen Endpunkt hinzufügen.

Mit den folgenden Befehlen werden beispielsweise ein Namespace, ein Dienst und ein Endpunkt erstellt, die das VPC-Netzwerk und die interne IP-Adresse Ihrer VM-Instanz angeben.

Erstellen Sie einen Namespace:
```
gcloud service-directory namespaces create NAMESPACE \
    --location=REGION
```
Ersetzen Sie Folgendes:
- NAMESPACE: die ID des Namespace oder die voll qualifizierte Kennung für den Namespace.
- REGION: Die Google Cloud-Region, die den Namespace enthält, z. B. us-central1.

Dienst erstellen:

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

Ersetzen Sie SERVICE durch den Namen des Dienstes, den Sie erstellen.

Konfigurieren Sie einen Endpunkt.

Hinweis: Konfigurieren Sie nur einen Endpunkt pro Service Directory-Dienst. Wenn mehr als ein Endpunkt konfiguriert ist, wählen Workflows willkürlich einen Endpunkt aus.
```
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
```
Ersetzen Sie Folgendes:
- ENDPOINT: der Name des Endpunkts, den Sie erstellen.
- PORT_NUMBER: der Port, auf dem der Endpunkt ausgeführt wird, z. B. 3000.
- IP_ADDRESS: die IPv6- oder IPv4-Adresse des Endpunkts. Das ist die interne IP-Adresse, die Sie zuvor notiert haben.

Weitere Informationen finden Sie unter Service Directory konfigurieren und Privaten Netzwerkzugriff konfigurieren.

Workflow erstellen und bereitstellen

Das Aufrufen oder Aufrufen eines privaten Endpunkts in Workflows erfolgt über eine HTTP-Anfrage. Die gängigsten HTTP-Anfragemethoden haben eine Aufrufverknüpfung (z. B. http.get und http.post). Sie können aber jede Art von HTTP-Anfrage stellen, indem Sie das Feld call auf http.request setzen und die Art der Anfrage im Feld method angeben. Weitere Informationen finden Sie unter HTTP-Anfrage stellen.

Erstellen Sie eine Quellcodedatei für Ihren Workflow:
```
touch call-private-endpoint.JSON_OR_YAML
```
Ersetzen Sie JSON_OR_YAML je nach Format Ihres Workflows durch yaml oder json.

Kopieren Sie in einem Texteditor den folgenden Workflow (in diesem Fall ein HTTP-Protokoll für den Wert url) in Ihre Quellcodedatei:

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

Der Wert für private_service_name muss ein String sein, der einen registrierten Service Directory-Dienstnamen im folgenden Format angibt:

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

Workflow bereitstellen Zu Testzwecken können Sie das Compute Engine-Standarddienstkonto an den Workflow anhängen, um dessen Identität darzustellen:
```
gcloud workflows deploy call-private-endpoint \
    --source=call-private-endpoint.JSON_OR_YAML \
    --location=REGION \
    --service-account=PROJECT_NUMBER-compute@developer.gserviceaccount.com
```
Achtung: Wir empfehlen, das Compute Engine-Standarddienstkonto nur zu Testzwecken zu verwenden. Für Produktionsumgebungen empfehlen wir dringend, ein neues Dienstkonto zu erstellen und ihm eine oder mehrere IAM-Rollen zuzuweisen, die die erforderlichen Mindestberechtigungen enthalten und dem Prinzip der geringsten Berechtigung folgen.

Führen Sie den Workflow aus:

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

Das Ergebnis sollte in etwa so aussehen:

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