Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Cloud Build mit einer Private Service Connect-Instanz verbinden

Sie können Cloud Build mit einer Secure Source Manager Private Service Connect-Instanz verbinden, indem Sie private Cloud Build-Pools verwenden. Diese Verbindung ist eine komplexere Alternative zur Verwendung von Developer Connect. Verwenden Sie den in dieser Anleitung beschriebenen Ansatz, wenn Sie keinen Git-Proxy-Endpunkt freigeben möchten.

Hinweis

Erstellen Sie eine Private Service Connect-Instanz von Secure Source Manager.
Wenn Sie die Endpunkte für Ihre Private Service Connect-Instanz bereits konfiguriert haben, müssen Sie die Verbindung trennen. Eine Anleitung zum Freigeben von Endpunkten finden Sie unter Statische interne IPv4- oder IPv6-Adresse freigeben.
Aktivieren Sie die Cloud Build API, die Service Networking API und die Compute Engine API.
Erforderliche Rollen zum Aktivieren von APIs
Zum Aktivieren von APIs benötigen Sie die IAM-Rolle „Service Usage-Administrator“ (roles/serviceusage.serviceUsageAdmin), die die Berechtigung serviceusage.services.enable enthält. Informationen zum Zuweisen von Rollen.
APIs aktivieren

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle „Access Context Manager-Administrator “ (roles/accesscontextmanager.policyAdmin) für die Organisation zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Verbinden von Cloud Build mit einer Private Service Connect-Instanz von Secure Source Manager benötigen.

Dienstkonto konfigurieren

Um das Prinzip der geringsten Berechtigung in Cloud Build zu befolgen, können Sie Cloud Build so konfigurieren, dass ein Dienst konto mit genau den Berechtigungen verwendet wird, die zum Ausführen eines Builds erforderlich sind.

Wenn Sie kein Dienstkonto angeben, wählt Cloud Build möglicherweise automatisch ein Dienstkonto aus, um Builds in Ihrem Namen auszuführen. Dieses Dienstkonto hat möglicherweise unnötig weit gefasste Berechtigungen für Ihren Anwendungsfall, z. B. Zugriff auf Ihre Secure Source Manager-Instanz und alle Repositories in Ihrem Projekt.

Erstellen Sie ein Dienstkonto, falls Sie noch keines haben, das Sie verwenden möchten.
Wechseln Sie in der Google Cloud Console zur Secure Source Manager Berechtigungen Seite:
Zu Berechtigungen
Wählen Sie auf dem Tab Dienstkontoberechtigungen das Dienstkonto aus, das Sie als Cloud Build-Dienstkonto verwenden möchten.
Optional können Sie Als bevorzugtes Dienstkonto festlegen auswählen, um Ihr Dienstkonto vorab auszufüllen, wenn Sie neue Trigger erstellen.

Erforderliche Berechtigungen für das Dienstkonto gewähren

Weisen Sie dem Dienstkonto die erforderlichen Cloud Build-Rollen für Ihren Anwendungsfall zu. Informationen zu den Cloud Build-Rollen, die für verschiedene Cloud Build-Aktionen erforderlich sind, finden Sie unter Zugriff auf Cloud Build konfigurieren.
Führen Sie den folgenden Befehl aus, um dem Dienstkonto Berechtigungen zum Abrufen des CA-Zertifikats zu gewähren.
```
gcloud projects add-iam-policy-binding CA_PROJECT_ID \
  --member=serviceAccount:SA_EMAIL \
  --role=roles/privateca.auditor \
  --condition=None
```
Ersetzen Sie Folgendes:
- CA_PROJECT_ID durch die Projekt-ID des Zertifizierungsstellenpoolprojekts.
- SA_EMAILdurch die E-Mail-Adresse des Dienstkontos, das Sie als Cloud Build-Dienstkonto festgelegt haben.

Führen Sie den folgenden Befehl aus, um dem Dienstkonto Berechtigungen für den Zugriff auf die Secure Source Manager-Instanz zu gewähren.

gcloud projects add-iam-policy-binding INSTANCE_PROJECT_ID \
  --member=serviceAccount:SA_EMAIL \
  --role=roles/securesourcemanager.instanceAccessor \
  --condition=None

Führen Sie den folgenden Befehl aus, um dem Dienstkonto Berechtigungen zum Lesen aus Secure Source Manager-Repositories zu gewähren.

gcloud projects add-iam-policy-binding INSTANCE_PROJECT_ID \
  --member=serviceAccount:SA_EMAIL \
  --role=roles/securesourcemanager.repoReader \
  --condition=None

Build-Logs einrichten

Wenn Sie ein eigenes Dienstkonto für Builds angeben, müssen Sie Ihre Build-Logs entweder in Cloud Logging oder in einem vom Nutzer erstellten Cloud Storage-Bucket speichern. Sie können Ihre Logs nicht im Standard-Log-Bucket speichern.

Wenn Sie Build-Logs in Cloud Logging speichern möchten, weisen Sie Ihrem Cloud Build-Dienstkonto die Rolle „Logautor“ (roles/logging.logWriter) zu.

Weitere Informationen zum Einrichten von Build-Logs finden Sie unter Benutzerdefinierte Dienstkonten konfigurieren.

Private Cloud DNS-Zone erstellen

Führen Sie den folgenden Befehl aus, um eine verwaltete private Cloud DNS-Zone zu erstellen.

gcloud dns managed-zones create ZONE_NAME \
    --project=PROJECT_ID \
    --description=DESCRIPTION \
    --dns-name="INSTANCE_LOCATION.p.sourcemanager.dev." \
    --visibility="private" \
    --networks="https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/NETWORK"

Ersetzen Sie Folgendes:

ZONE_NAME durch den Namen, den Sie der verwalteten Zone geben möchten.
PROJECT_ID durch die Projekt-ID des Google Cloud Projekts, das Sie für die Cloud DNS-Zone verwenden möchten.
DESCRIPTION durch eine Beschreibung für die Zone.
INSTANCE_LOCATIONdurch den Standort, an dem Sie Ihre Secure Source Manager-Instanz erstellen möchten.

Weitere Informationen zu verwalteten privaten Cloud DNS-Zonen finden Sie unter Cloud DNS – Übersicht.

VPC-Netzwerk (Virtual Private Cloud) konfigurieren

Reservieren Sie einen IP-Bereich, den Sie verwenden möchten, um die Secure Source Manager-VPC mit dem privaten Cloud Build-Pool zu verbinden.
```
 gcloud compute addresses create CB_PEER_RANGE \
  --global \
  --purpose=VPC_PEERING \
  --prefix-length=24 \
  --description="IP range for peering with Cloud Build private pool" \
  --network=NETWORK \
  --project=INSTANCE_PROJECT_ID
```
Ersetzen Sie Folgendes:
- CB_PEER_RANGE durch den Namen der zu erstellenden Adresse.
- NETWORKdurch die Netzwerkressource, in der die Adressen reserviert werden sollen. Wenn Sie das Standardnetzwerk verwenden, ist der Wert default.
- INSTANCE_PROJECT_IDdurch die Projekt-ID der Private Service Connect-Instanz.

Führen Sie den folgenden Befehl aus, um ein VPC-Peering mit servicenetworking.googleapis.com zu erstellen.

gcloud services vpc-peerings connect \
  --service=servicenetworking.googleapis.com \
  --ranges=CB_PEER_RANGE \
  --network=NETWORK \
  --project=INSTANCE_PROJECT_ID

Führen Sie den folgenden Befehl aus, um eine Peering-DNS-Domain zu erstellen, um eine Verbindung mit Cloud Build herzustellen.
```
gcloud services peered-dns-domains create DNS_PEERING_DOMAIN \
  --network=NETWORK \
  --project=INSTANCE_PROJECT_ID \
  --dns-suffix=INSTANCE_LOCATION.p.sourcemanager.dev.
```
Ersetzen Sie Folgendes:
- DNS_PEERING_DOMAINdurch den Namen der Peering-DNS-Domain, die Sie erstellen.
Private DNS-Zonen müssen explizit freigegeben werden. Weitere Informationen zum Freigeben privater DNS-Zonen finden Sie unter Private DNS-Zonen für Dienstersteller freigeben.

Führen Sie den folgenden Befehl aus, um Netzwerkrouten nach Cloud Build zu exportieren.

gcloud compute networks peerings update servicenetworking-googleapis-com \
  --network=NETWORK \
  --export-custom-routes \
  --no-export-subnet-routes-with-public-ip \
  --project=INSTANCE_PROJECT_ID

Führen Sie den folgenden Befehl aus, um den privaten Cloud Build-Pool im selben Google Cloud Projekt wie die Private Service Connect-Instanz zu erstellen.
```
gcloud builds worker-pools create PRIVATE_POOL_ID \
  --project=INSTANCE_PROJECT_ID \
  --region=INSTANCE_LOCATION \
  --peered-network=projects/INSTANCE_PROJECT_ID/global/networks/NETWORK \
  --worker-disk-size=100 \
  --no-public-egress
```
Dabei ist PRIVATE_POOL_ID der Name des privaten Pools, den Sie erstellen. Der Name muss zwischen 1 und 63 Zeichen lang sein. Gültige Zeichen sind [a-zA-Z0-9_-]+.

Führen Sie den folgenden Befehl aus, um eine Private Service Connect-Netzwerk-Endpunktgruppe (NEG) für den HTTP-Endpunkt zu erstellen:

gcloud compute network-endpoint-groups create HTTP_NEG_NAME \
    --project=INSTANCE_PROJECT_ID \
    --region=INSTANCE_LOCATION \
    --network-endpoint-type=PRIVATE_SERVICE_CONNECT \
    --psc-target-service=HTTP_PSC \
    --network=NETWORK --subnet=SUBNET

Wobei:

HTTP_NEG_NAME der Name der NEG ist, die Sie für den HTTP-Endpunkt erstellen möchten.
HTTP_PSC der Wert des HTTP Private Service Connect-Endpunkts ist.

Führen Sie den folgenden Befehl aus, um eine Private Service Connect-NEG für den SSH-Endpunkt zu erstellen:

gcloud compute network-endpoint-groups create SSH_NEG_NAME \
  --project=INSTANCE_PROJECT_ID \
  --region=INSTANCE_LOCATION \
  --network-endpoint-type=PRIVATE_SERVICE_CONNECT \
  --psc-target-service=SSH_PSC \
  --network=NETWORK --subnet=SUBNET

Wobei:

SSH_NEG_NAME der Name der NEG ist, die Sie für den SSH-Endpunkt erstellen möchten.
SSH_PSC der Wert des SSH Private Service Connect-Endpunkts ist.

Internen Proxy-Load-Balancer (ILB) einrichten

Endpunkte sind über Peering-VPC-Netzwerke nicht erreichbar. Um auf die Secure Source Manager-Endpunkte zuzugreifen, müssen Sie für jeden Endpunkt einen internen L4-Load-Balancer (ILB) einrichten. Weitere Informationen zum Zugriff auf veröffentlichte Dienste über Endpunkte finden Sie unter Zugriff auf veröffentlichte Dienste über Endpunkte.

Führen Sie den folgenden Befehl aus, um ein Nur-Proxy-Subnetz für ILBs zu erstellen.
```
gcloud compute networks subnets create ILB_PROXY_SUBNET_NAME \
--purpose=REGIONAL_MANAGED_PROXY \
--role=ACTIVE \
--region=INSTANCE_LOCATION \
--network=NETWORK \
--range=CIDR_RANGE \
--project=INSTANCE_PROJECT_ID
```
Wobei:
- ILB_PROXY_SUBNET_NAME der Name des zu erstellenden Subnetzes ist.
- CIDR_RANGE der primäre IP-Adressbereich des Subnetzes ist. Die Subnetzmaske darf maximal 26 lang sein, damit mindestens 64 IP-Adressen für Proxys in der Region verfügbar sind. Die empfohlene Länge der Subnetzmaske ist /23. Weitere Informationen zu Nur-Proxy-Subnetzen finden Sie unter Nur-Proxy-Subnetze für Envoy-basierte Load-Balancer.
Führen Sie den folgenden Befehl aus, um einen L4-ILB für die HTTP-Verbindungs-NEG zu erstellen.
```
gcloud compute backend-services create HTTP_PROXY_ILB \
  --project=INSTANCE_PROJECT_ID \
  --region=INSTANCE_LOCATION \
  --load-balancing-scheme=INTERNAL_MANAGED
```
Dabei ist HTTP_PROXY_ILB der Name des ILB, der für den HTTP-Endpunkt erstellt werden soll.

Führen Sie den folgenden Befehl aus, um einen L4-ILB für die SSH-Verbindungs-NEG zu erstellen.

gcloud compute backend-services create SSH_PROXY_ILB \
    --project=INSTANCE_PROJECT_ID \
    --region=INSTANCE_LOCATION \
    --load-balancing-scheme=INTERNAL_MANAGED

Dabei ist SSH_PROXY_ILB der Name des ILB, der für den SSH-Endpunkt erstellt werden soll.

Private Service Connect-NEG als Backend der ILBs registrieren

Führen Sie den folgenden Befehl aus, um die HTTP-NEG zu registrieren.

gcloud compute backend-services add-backend HTTP_PROXY_ILB \
  --network-endpoint-group=HTTP_NEG_NAME \
  --network-endpoint-group-region=INSTANCE_LOCATION \
  --project=INSTANCE_PROJECT_ID

Führen Sie den folgenden Befehl aus, um die SSH-NEG zu registrieren.

gcloud compute backend-services add-backend SSH_PROXY_ILB \
  --network-endpoint-group=SSH_NEG_NAME \
  --network-endpoint-group-region=INSTANCE_LOCATION \
  --project=INSTANCE_PROJECT_ID

Ziel-TCP-Proxys für die ILBs erstellen

Führen Sie den folgenden Befehl aus, um einen Ziel-TCP-Proxy für den HTTP-ILB zu erstellen.
```
gcloud compute target-tcp-proxies create ILB_HTTP_TCP_TARGET_PROXY \
  --backend-service=HTTP_PROXY_ILB \
  --region=INSTANCE_LOCATION \
  --project=INSTANCE_PROJECT_ID
```
Dabei ist ILB_HTTP_TCP_TARGET_PROXY der Name des Ziel-TCP-Proxys, den Sie für den HTTP-ILB erstellen möchten.
Führen Sie den folgenden Befehl aus, um einen Ziel-TCP-Proxy für den SSH-ILB zu erstellen.
```
gcloud compute target-tcp-proxies create ILB_SSH_TCP_TARGET_PROXY \
  --backend-service=SSH_PROXY_ILB \
  --region=INSTANCE_LOCATION \
  --project=INSTANCE_PROJECT_ID
```
Dabei ist ILB_SSH_TP_TARGET_PROXY der Name des Ziel-TCP-Proxys, den Sie für den SSH-ILB erstellen.

Weiterleitungsregeln erstellen, um Traffic an die ILBs weiterzuleiten

Führen Sie den folgenden Befehl aus, um eine Weiterleitungsregel zum Weiterleiten von Traffic an den HTTP-ILB zu erstellen.

gcloud compute forwarding-rules create HTTP_PROXY_FORWARD \
    --project=INSTANCE_PROJECT_ID \
    --ports 443 \
    --target-tcp-proxy=ILB_HTTP_TCP_TARGET_PROXY \
    --target-tcp-proxy-region=INSTANCE_LOCATION \
    --network-tier PREMIUM \
    --load-balancing-scheme=INTERNAL_MANAGED \
    --network=NETWORK \
    --subnet=SUBNET \
    --subnet-region=INSTANCE_LOCATION

Dabei ist HTTP_PROXY_FORWARD der Name der Weiterleitungsregel, die Sie erstellen.

Führen Sie den folgenden Befehl aus, um eine Weiterleitungsregel zum Weiterleiten von Traffic an den SSH-ILB zu erstellen.

gcloud compute forwarding-rules create SSH_PROXY_FORWARD \
    --project=INSTANCE_PROJECT_ID \
    --ports 22 \
    --target-tcp-proxy=ILB_SSH_TCP_TARGET_PROXY \
    --target-tcp-proxy-region=INSTANCE_LOCATION \
    --network-tier PREMIUM \
    --load-balancing-scheme=INTERNAL_MANAGED \
    --network=NETWORK \
    --subnet=SUBNET \
    --subnet-region=INSTANCE_LOCATION

Dabei ist SSH_PROXY_FORWARD der Name der Weiterleitungsregel, die Sie erstellen.

Private DNS-Einträge erstellen

Nachdem die Weiterleitungsregeln eingerichtet sind, müssen Sie DNS-Einträge in Ihrer privaten Cloud DNS-Zone für jeden Hostnamen der Instanz registrieren.

Führen Sie den folgenden Befehl aus, um die IP-Adresse für Ihre HTTP-Weiterleitungsregel abzurufen.
```
gcloud compute forwarding-rules describe HTTP_PROXY_FORWARD \
    --project=INSTANCE_PROJECT_ID \
    --region=INSTANCE_LOCATION
```
Dabei ist HTTP_PROXY_FORWARD der Name, den Sie der Weiterleitungsregel für HTTP gegeben haben.
Führen Sie den folgenden Befehl aus, um den API-Hostnamen zu registrieren.
```
gcloud dns record-sets create INSTANCE_ID-INSTANCE_PROJECT_NUMBER-api.INSTANCE_LOCATION.p.sourcemanager.dev. \
    --project=INSTANCE_PROJECT_ID \
    --zone=ZONE_NAME \
    --type=A \
    --ttl=300 \
    --rrdatas=HTTP_LB_IP
```
Ersetzen Sie Folgendes:
- INSTANCE_ID durch Ihre Instanz-ID.
- INSTANCE_PROJECT_NUMBER durch die Projektnummer Ihrer Instanz. Google Cloud
- INSTANCE_LOCATION durch die Region Ihrer Instanz.
- INSTANCE_PROJECT_ID durch die Projekt-ID Ihrer Instanz. Google Cloud
- ZONE_NAME durch den Namen, den Sie der verwalteten Zone gegeben haben.
- HTTP_LB_IP ist die Ausgabe von gcloud compute forwarding-rules describe HTTP_PROXY_FORWARD.

Führen Sie den folgenden Befehl aus, um den Git-HTTP-Hostnamen zu registrieren.

gcloud dns record-sets create INSTANCE_ID-INSTANCE_PROJECT_NUMBER-git.INSTANCE_LOCATION.p.sourcemanager.dev. \
    --project=INSTANCE_PROJECT_ID \
    --zone=ZONE_NAME \
    --type=A \
    --ttl=300 \
    --rrdatas=HTTP_LB_IP

Führen Sie den folgenden Befehl aus, um den HTML-Hostnamen für die Weboberfläche zu registrieren.

gcloud dns record-sets create INSTANCE_ID-INSTANCE_PROJECT_NUMBER.INSTANCE_LOCATION.p.sourcemanager.dev.\
    --project=INSTANCE_PROJECT_ID \
    --zone=ZONE_NAME \
    --type=A \
    --ttl=300 \
  --rrdatas=HTTP_LB_IP

Führen Sie den folgenden Befehl aus, um die IP-Adresse für Ihre SSH-Weiterleitungsregel abzurufen.
```
gcloud compute forwarding-rules describe SSH_PROXY_FORWARD \
    --project=INSTANCE_PROJECT_ID \
    --region=INSTANCE_LOCATION
```
Dabei ist SSH_PROXY_FORWARD der Name, den Sie der Weiterleitungsregel für SSH gegeben haben.

Führen Sie den folgenden Befehl aus, um den Git-SSH-Hostnamen zu registrieren.

gcloud dns record-sets create INSTANCE_ID-INSTANCE_PROJECT_NUMBER-ssh.INSTANCE_LOCATION.p.sourcemanager.dev. \
    --project=INSTANCE_PROJECT_ID \
    --zone=ZONE_NAME \
    --type=A \
    --ttl=300 \
    --rrdatas=SSH_LB_IP

Dabei ist SSH_LB_IP die Ausgabe von gcloud compute forwarding-rules describe SSH_PROXY_FORWARD.

Repository in der Instanz erstellen

Sie können einen Bastion Host verwenden, um auf ein Repository in Ihrer Private Service Connect-Instanz zuzugreifen und es zu erstellen.

Erstellen Sie eine Bastion-Host-VM mit dem cloud-platform Bereich . Folgen Sie dazu der Anleitung unter Bastion-Host-VM erstellen.
Erstellen Sie ein Repository mit dem folgenden Befehl.
```
curl \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
https://INSTANCE_ID-PROJECT_NUMBER-api.INSTANCE_LOCATION.p.sourcemanager.dev/v1/projects/PROJECT_NUMBER/locations/INSTANCE_LOCATION/repositories?repository_id=REPOSITORY_ID \
-d '{}'
```
Ersetzen Sie Folgendes:
- INSTANCE_IDdurch den Namen Ihrer Secure Source Manager-Instanz.
- PROJECT_NUMBER durch die Projektnummer Ihrer Instanz. Google Cloud
- INSTANCE_LOCATION durch den Standort Ihrer Instanz.
- REPOSITORY_IDdurch den Namen, den Sie Ihrem Repository geben möchten.
In Ihrer Private Service Connect-Instanz wird ein Repository erstellt.

Zugriff auf Secure Source Manager von Cloud Build aus testen

Um zu prüfen, ob alles ordnungsgemäß funktioniert, können Sie mit der folgenden Build-Konfigurationsdatei die Verbindung testen und Quellcode aus Secure Source Manager abrufen. In der Build-Konfigurationsdatei wird davon ausgegangen, dass Sie Cloud Logging zum Speichern Ihrer Build-Logs verwenden. Wenn Sie einen vom Nutzer erstellten Cloud Storage-Bucket verwenden, finden Sie unter Build mit einer Konfigurationsdatei ausführen eine Anleitung zum Bearbeiten der Build-Konfigurationsdatei.

Bevor Sie die folgende YAML-Datei verwenden, ersetzen Sie Folgendes:

CA_POOL_NAMEdurch den Namen des Zertifizierungsstellenpools, den Sie beim Erstellen Ihrer Private Service Connect-Instanz verwendet haben.
CA_PROJECT_ID durch das Google Cloud Projekt, das Sie zum Erstellen des Zertifizierungsstellenpools verwendet haben.
INSTANCE_LOCATION durch den Standort Ihrer Instanz.
INSTANCE_ID durch den Namen Ihrer Instanz.
INSTANCE_PROJECT_NUMBER durch die Projektnummer Ihrer Instanz. Google Cloud
REPOSITORY_ID durch den Namen, den Sie Ihrem Repository gegeben haben.
SA_PROJECT_IDdurch die Projekt-ID des Dienstkontos, das Sie mit Cloud Build verwenden.
SERVICE_ACCOUNTdurch die E-Mail-Adresse des Dienstkontos, das Sie mit Cloud Build verwenden.

steps:
  - name: gcr.io/cloud-builders/gcloud
    args:
      - privateca
      - pools
      - get-ca-certs
      - CA_POOL_NAME
      - '--project'
      - CA_PROJECT_ID
      - '--location'
      - INSTANCE_LOCATION
      - '--output-file=cacert.pem'
  - name: gcr.io/cloud-builders/git
    args:
      - config
      - '--global'
      - 'credential.https://INSTANCE_ID-INSTANCE_PROJECT_NUMBER-git.INSTANCE_LOCATION.p.sourcemanager.dev.helper'
      - gcloud.sh
  - name: gcr.io/cloud-builders/git
    args:
      - config
      - '--global'
      - http.sslCAInfo
      - cacert.pem
  - name: gcr.io/cloud-builders/git
    env:
      - GIT_TRACE=1
      - GIT_CURL_VERBOSE=1
    args:
      - clone
      - >-
        https://INSTANCE_ID-INSTANCE_PROJECT_NUMBER-git.INSTANCE_LOCATION.p.sourcemanager.dev/INSTANCE_PROJECT_ID/REPOSITORY_ID
      - https-clone
serviceAccount: 'projects/SA_PROJECT_ID/serviceAccounts/SERVICE_ACCOUNT'
options:
  logging: CLOUD_LOGGING_ONLY

Nächste Schritte

Wenn Sie Builds aus Secure Source Manager automatisieren möchten, folgen Sie der Anleitung unter Triggerdatei erstellen.

Cloud Build mit einer Private Service Connect-Instanz verbinden Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.