Diese Seite wurde von der Cloud Translation API übersetzt.

Cloud Build mit einer Private Service Connect-Instanz verbinden

Sie können Cloud Build über private Cloud Build-Pools mit einer Secure Source Manager Private Service Connect-Instanz verbinden.

Hinweise

Private Service Connect Secure Source Manager-Instanz erstellen
Wenn Sie die Endpunkte für Ihre Private Service Connect-Instanz bereits konfiguriert haben, müssen Sie die Verbindung trennen. Wenn Sie Ihre Endpunkte freigeben möchten, folgen Sie der Anleitung unter Statische interne IPv4- oder IPv6-Adresse freigeben.
Enable the Cloud Build, Service Networking, and Compute Engine APIs.
Enable the APIs

Erforderliche Rollen

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

Dienstkonto konfigurieren

Um den Grundsatz der geringsten Berechtigung in Cloud Build zu befolgen, können Sie Cloud Build so konfigurieren, dass ein Dienstkonto 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 Berechtigungen, die für Ihren Anwendungsfall unnötig umfassend sind, z. B. Zugriff auf Ihre Secure Source Manager-Instanz und alle Repositorys in Ihrem Projekt.

Erstellen Sie ein Dienstkonto, falls Sie noch keines haben, das Sie verwenden möchten.
Rufen Sie in der Google Cloud Console die Seite Secure Source Manager Berechtigungen auf:
Zur Seite 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 dazu, welche Cloud Build-Rollen 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 erteilen.
```
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: mit der Projekt-ID des CA-Pool-Projekts.
- SA_EMAIL: mit der 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.

Zum Speichern von Build-Logs in Cloud Logging 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: der Name, den Sie der verwalteten Zone geben möchten.
PROJECT_ID: mit der Projekt-ID des Google Cloud Projekts, das Sie für die Cloud DNS-Zone verwenden möchten.
DESCRIPTION: mit einer Beschreibung der Zone.
INSTANCE_LOCATION: Der 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 für das Peering der Secure Source Manager-VPC mit dem privaten Cloud Build-Pool verwenden möchten.
```
 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: Der Name der zu erstellenden Adresse.
- NETWORK: die Netzwerkressource, in der die Adressen reserviert werden sollen. Wenn Sie das Standardnetzwerk verwenden, ist der Wert default.
- INSTANCE_PROJECT_ID: mit der 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 für die Verbindung mit Cloud Build zu erstellen.
```
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_DOMAIN: mit dem Namen der zu erstellenden Peering-DNS-Domain.
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 CloudProjekt 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 beta 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 ist der Name des NEG, das Sie für den HTTP-Endpunkt erstellen möchten.
HTTP_PSC ist der HTTP Private Service Connect-Endpunktwert.

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

gcloud beta 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 ist der Name der NEG, die Sie für den SSH-Endpunkt erstellen möchten.
SSH_PSC ist der Wert des SSH Private Service Connect-Endpunkts.

Proxy-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 ist der Name des zu erstellenden Subnetzes.
- CIDR_RANGE ist der primäre IP-Adressbereich des Subnetzes. Die Subnetzmaske darf maximal 26 lang sein, damit mindestens 64 IP-Adressen für Proxys in der Region verfügbar sind. Als Länge der Subnetzmaske wird /23 empfohlen. 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 das NEG für die HTTP-Verbindung 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 ILB der Schicht 4 für die NEG der SSH-Verbindung 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

Registrieren Sie das HTTP NEG mit dem folgenden Befehl.

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 TCP-Zielproxy 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 TCP-Zielproxys, den Sie für den HTTP-ILB erstellen möchten.
Führen Sie den folgenden Befehl aus, um einen TCP-Zielproxy 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 zum Weiterleiten von Traffic an die ILBs erstellen

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 internen SSH-Lastenausgleich 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 wurden, müssen Sie für jeden Hostnamen der Instanz DNS-Einträge in Ihrer privaten Cloud DNS-Zone 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-Hostname 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: mit Ihrer Instanz-ID.
- INSTANCE_PROJECT_NUMBER: mit der Projektnummer Google CloudIhrer Instanz.
- INSTANCE_LOCATION: mit der Region Ihrer Instanz.
- INSTANCE_PROJECT_ID: mit der Projekt-ID Ihrer Instanz Google Cloud.
- ZONE_NAME: mit dem Namen, den Sie der verwalteten Zone gegeben haben.
- HTTP_LB_IP: die Ausgabe von gcloud compute forwarding-rules describe HTTP_PROXY_FORWARD.

Führen Sie den folgenden Befehl aus, um den Git-HTTP-Hostname 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 Ihrer Instanz erstellen

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

Erstellen Sie eine Bastion-Host-VM mit dem cloud-platform-Bereich, indem Sie der Anleitung unter Bastion-Host-VM erstellen folgen.
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_ID durch den Namen Ihrer Secure Source Manager-Instanz.
- PROJECT_NUMBER: mit der Google Cloud Projektnummer Ihrer Instanz.
- INSTANCE_LOCATION: mit dem Standort Ihrer Instanz.
- REPOSITORY_ID: mit dem Namen, den Sie Ihrem Repository geben möchten.
In Ihrer Private Service Connect-Instanz wird ein Repository erstellt.

Zugriff auf Secure Source Manager über Cloud Build testen

Um zu bestätigen, dass alles ordnungsgemäß funktioniert, können Sie die folgende Build-Konfigurationsdatei verwenden, um die Verbindung zu testen und Quellcode aus Secure Source Manager abzurufen. 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_NAME: mit dem Namen des CA-Pools, den Sie beim Erstellen Ihrer Private Service Connect-Instanz verwendet haben.
CA_PROJECT_ID: mit dem Google Cloud Projekt, das Sie zum Erstellen des CA-Pools verwendet haben.
INSTANCE_LOCATION: mit dem Standort Ihrer Instanz.
INSTANCE_ID durch den Namen Ihrer Instanz.
INSTANCE_PROJECT_NUMBER: mit der Google Cloud Projektnummer Ihrer Instanz.
REPOSITORY_ID: mit dem Namen, den Sie Ihrem Repository gegeben haben.
SA_PROJECT_ID durch die Projekt-ID des Dienstkontos, das Sie mit Cloud Build verwenden.
SERVICE_ACCOUNT: mit der 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.