Diese Seite wurde von der Cloud Translation API übersetzt.

VPC Service Controls-konformen privaten Endpunkt aufrufen

Sie können einen privaten Endpunkt für HTTP-Aufrufe aus Ihrer Workflowausführung festlegen, indem Sie Service Directory-Dienstregistrierung mit Workflows verwenden. Wenn Sie einen privaten Endpunkt in einem VPC-Netzwerk (Virtual Private Cloud) erstellen, kann der Endpunkt VPC Service Controls-konform sein.

VPC Service Controls bietet eine zusätzliche Sicherheitsebene, die unabhängig von der Identitäts- und Zugriffsverwaltung (Identity and Access Management, IAM) ist. Im Gegensatz zur detaillierten identitätsbasierten Zugriffssteuerung von IAM ermöglicht VPC Service Controls eine breitere kontextbasierte Perimetersicherheit, einschließlich der Kontrolle ausgehender Datenübertragungen im gesamten Perimeter.

Service Directory ist ein Dienstregistrierung, die Informationen zu registrierten Netzwerkdiensten, einschließlich ihrer Namen, Orte und Attribute. Unabhängig von ihrer Infrastruktur können Sie Dienste automatisch registrieren und ihre Details erfassen. So können Sie Dienste für alle Ihre Dienstendpunkte in großem Umfang erkennen, veröffentlichen und verbinden.
Ein VPC-Netzwerk stellt eine Verbindung für Ihre VM-Instanzen bereit und ermöglicht es Ihnen, mithilfe interner IP-Adressen private Endpunkte innerhalb Ihres VPC-Netzwerks zu erstellen. HTTP Aufrufe einer VPC-Netzwerkressource werden über ein privates Netzwerk gesendet. und IAM und VPC Service Controls erzwingen.
VPC Service Controls ist ein Google Cloud-Feature, mit dem Sie einen Dienstperimeter einrichten und einer Datenübertragungsgrenze. 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 registrieren als Service Directory-Endpunkt senden. So können Sie Ihrem Workflow einen Service Directory-Dienstnamen zuweisen. Bei der Workflowausführung werden die Informationen aus der Dienstregistrierung verwendet, um die entsprechende HTTP-Anfrage zu senden, ohne dass eine Verbindung zu einem öffentlichen Netzwerk hergestellt wird.

Dieses Diagramm bietet eine Übersicht:

HTTP-Anfrage an eine Portnummer auf einer VM-Instanz mit Informationen aus dem Dienstverzeichnis senden

Hier ist eine allgemeine Liste der erforderlichen Aufgaben:

Weisen Sie dem Cloud Workflows-Dienst-Agent Berechtigungen zu, damit er Service Directory-Ressourcen aufrufen und über Service Directory auf VPC-Netzwerke zugreifen kann.
Erstellen Sie ein VPC-Netzwerk, um Netzwerkfunktionen bereitzustellen.
Erstellen Sie eine VPC-Firewallregel, damit Sie kann Traffic zu oder von VM-Instanzen in Ihrer VPC zulassen oder ablehnen Netzwerk.
Erstellen Sie eine VM-Instanz im VPC-Netzwerk. Eine Compute Engine-VM-Instanz ist eine virtuelle Maschine, die in der Infrastruktur von Google gehostet wird. Die Begriffe Compute Engine-Instanz, VM-Instanz und VM sind synonym und werden synonym verwendet.
Anwendung auf der VM bereitstellen Sie können eine App auf Ihrem VM-Instanz und bestätigen Sie, dass der Traffic wie erwartet bereitgestellt wird.
Service Directory konfigurieren damit Ihre Workflowausführung ein Service Directory aufrufen kann Endpunkt.

Hinweis: Konfigurieren Sie nur einen Endpunkt pro Service Directory-Dienst. Wenn mehr als ein Endpunkt konfiguriert ist, einen Endpunkt willkürlich auswählt.
Erstellen und bereitstellen des Workflows Der Wert private_service_name in Ihrem Workflow gibt den Service Directory-Endpunkt an, den Sie im vorherigen Schritt registriert haben.

Berechtigungen für den Cloud Workflows-Dienst-Agent erteilen

Einige Google Cloud-Dienste haben Dienst-Agenten damit Dienste auf Ihre Ressourcen zugreifen können. 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 dem folgenden Befehl können Sie das Dienstkonto manuell in einem Projekt ohne Workflows erstellen:
```
gcloud beta services identity create \
    --service=workflows.googleapis.com \
    --project=PROJECT_ID
```
Ersetzen Sie PROJECT_ID durch die Google Cloud-Projekt-ID.
Damit der Workflows-Dienst-Agent Service Directory-Ressourcen aufrufen kann, weisen Sie ihm die Rolle Service Directory-Betrachter (servicedirectory.viewer) für das Projekt zu:
```
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)'
```
Für den Zugriff auf VPC-Netzwerke über Service Directory gewähren Rolle „Autorisierter Private Service Connect-Dienst“ (roles/servicedirectory.pscAuthorizedService) für das Projekt an die Workflows-Dienst-Agent:
```
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 im automatischen oder benutzerdefinierten Modus Netzwerk. Jedes neu erstellte Netzwerk muss innerhalb des Projekt arbeiten.

Mit dem folgenden Befehl wird beispielsweise eine VPC im automatischen Modus erstellt. Netzwerk:

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 zur oder von einer VM zulassen oder ablehnen in einem VPC-Netzwerk basierend auf Portnummer, Tag oder Protokoll.

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 bestimmtes VPC-Netzwerk erstellt, die eingehenden Traffic von jeder IPv4-Adresse (0.0.0.0/0) zulässt. Wenn der Flag-Wert von --rules all ist, gilt die Regel für alle Protokolle und Zielports.

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 privaten Netzwerkzugriff kann eine VPC-Netzwerkressource eine VM-Instanz sein, Cloud Interconnect-IP-Adresse oder ein interner Layer-4-Load-Balancer.

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

Sie können die Maschinenattribute Ihrer Instanzen auswählen, z. B. die Anzahl der virtuellen CPUs oder die Größe des Arbeitsspeichers, und zwar entweder mit vordefinierten Maschinentypen oder mit Ihren eigenen benutzerdefinierten Maschinentypen.

Mit dem folgenden Befehl wird beispielsweise eine Linux-VM-Instanz aus einer öffentlichen Bild mit einer Netzwerkschnittstelle, die mit dem VPC-Netzwerk verbunden ist, die zuvor erstellt wurden.

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

Zu 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.
Klicken Sie zum Bearbeiten der VM auf Bearbeiten.
Unter Netzwerk > Firewalls können Sie HTTP- oder HTTPS-Traffic zur VM verwenden möchten, wählen Sie HTTP-Traffic zulassen oder HTTPS-Traffic zulassen

Klicken Sie in diesem Beispiel das Kästchen HTTP-Traffic zulassen an.

Die Compute Engine fügt Ihrer VM ein Netzwerk-Tag hinzu, das die Firewallregel mit der VM verknüpft. Anschließend wird die entsprechende Firewall 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

Um die Netzwerkkonfiguration zu testen und zu überprüfen, ob Traffic bereitgestellt wird als können Sie auf Ihrer VM eine einfache Anwendung bereitstellen, die einen Port überwacht.

Mit den folgenden Befehlen wird beispielsweise ein Node.js-Webdienst erstellt, der auf Port 3000 wartet.

SSH-Verbindung zur VM herstellen Instanz.
Aktualisieren Sie die Paket-Repositorys:
```
sudo apt update
```
Installieren Sie NVM, Node.js und npm.

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

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

Die Webanwendung Express installieren 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 App erstellt, die auf GET-Anfragen an den Stammpfad (/) mit dem Text „Hallo Welt!“ 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 sich den Port, den die App überwacht. Die gleiche Portnummer muss beim Konfigurieren des Endpunkts für den Service Directory-Dienst 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 das Aufrufen eines privaten Endpunkts aus einer Workflowausführung unterstützt wird, müssen Sie Folgendes festlegen: Service Directory-Namespace erstellen, einen Dienst im Namespace und fügen dem Dienst einen Endpunkt hinzu.

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

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

So erstellen Sie einen Dienst:

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. Service. Wenn mehr als ein Endpunkt konfiguriert ist, einen Endpunkt willkürlich auswählt.
```
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 Ihres Endpunkts erstellen.
- PORT_NUMBER: der Port, auf dem der Endpunkt ausgeführt wird, z. B. 3000.
- IP_ADDRESS: die IPv6- oder IPv4-Adresse des Endpunkts. Dies ist die interne IP-Adresse, die Sie zuvor notiert haben.

Weitere Informationen finden Sie unter Dienstverzeichnis konfigurieren und Zugriff auf privates Netzwerk konfigurieren.

Workflow erstellen und bereitstellen

Der Aufruf eines privaten Endpunkts über Workflows erfolgt über eine HTTP-Anfrage. Die gängigsten Methoden für HTTP-Anfragen haben eine Aufrufverknüpfung wie http.get und http.post. Sie können aber eine beliebige Methode verwenden, um Typ der HTTP-Anfrage. Dazu setzen Sie das Feld call auf http.request und geben den Anfragetyp im Feld method an. 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“ durch „yaml“ oder „json“ je nach Format des Workflows.

Kopieren Sie den folgenden Workflow (der in diesem Fall ein HTTP-Protokoll für den Wert url verwendet) in einen Texteditor und fügen Sie ihn in die Quellcodedatei ein:

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 Dienstnamen des Dienstes „Service Directory“ im folgenden Format angibt:

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

Stellen Sie den Workflow bereit. Zu Testzwecken können Sie die Compute Engine Standarddienstkonto zum Workflow hinzufügen, um seine 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, die Compute Engine-Standardeinstellung zu verwenden. Dienstkonto nur zu Testzwecken. Für Produktionsumgebungen dringend empfehlen Erstellen eines neuen Dienstkontos und gewähren Sie ihm eine oder mehrere IAM-Rollen, die das Minimum und das Prinzip der geringste Berechtigung.

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