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

Conecta Cloud Build a una instancia de Private Service Connect

Puedes conectar Cloud Build a una instancia de Private Service Connect de Secure Source Manager con grupos privados de Cloud Build. Esta conexión es una alternativa más compleja al uso de Developer Connect. Usa el enfoque que se describe en esta guía si no te sientes cómodo con la exposición de un extremo de proxy de Git.

Antes de comenzar

Crea una instancia de Private Service Connect de Secure Source Manager.
Si configuraste previamente los extremos de tu instancia de Private Service Connect, debes desconectarlos. Para liberar tus extremos, sigue las instrucciones que se indican en Libera una dirección IPv4 o IPv6 interna estática.
Habilita las APIs de Cloud Build, Service Networking y Compute Engine.
Roles necesarios para habilitar las APIs
Para habilitar las APIs, necesitas el rol de IAM de administrador de Service Usage (roles/serviceusage.serviceUsageAdmin), que contiene el permiso serviceusage.services.enable. Obtén más información para otorgar roles.
Habilitar las API

Roles obligatorios

Para obtener los permisos que necesitas para conectar Cloud Build a una instancia de Private Service Connect de Secure Source Manager, pídele a tu administrador que te otorgue el rol de IAM de administrador de Access Context Manager (roles/accesscontextmanager.policyAdmin) en la organización.

Configura tu cuenta de servicio

Para seguir el principio de privilegio mínimo en Cloud Build, puedes configurar Cloud Build para usar una cuenta de servicio con los privilegios suficientes para ejecutar una compilación.

Si no especificas una cuenta de servicio, es posible que Cloud Build seleccione automáticamente una cuenta de servicio para ejecutar compilaciones en tu nombre. Esta cuenta de servicio puede tener permisos que son innecesariamente amplios para tu caso de uso, como el acceso a tu instancia de Secure Source Manager y a cualquier repositorio de tu proyecto.

Crea una cuenta de servicio si aún no tienes una que quieras usar.
En la Google Cloud consola, ve a la página Permissions de Secure Source Manager:
Ir a Permissions
En la pestaña Service account permissions, selecciona la cuenta de servicio que deseas usar como cuenta de servicio de Cloud Build.
De manera opcional, selecciona Set as preferred service account para completar previamente tu cuenta de servicio cuando crees activadores nuevos.

Otorga los permisos necesarios a la cuenta de servicio

Otorga a la cuenta de servicio los roles de Cloud Build necesarios para tu caso de uso. Para obtener información sobre qué roles de Cloud Build son necesarios para diferentes acciones de Cloud Build, consulta Configura el acceso a Cloud Build.
Para otorgar a la cuenta de servicio permisos para recuperar el certificado de la AC, ejecuta el siguiente comando.
```
gcloud projects add-iam-policy-binding CA_PROJECT_ID \
  --member=serviceAccount:SA_EMAIL \
  --role=roles/privateca.auditor \
  --condition=None
```
Reemplaza lo siguiente:
- CA_PROJECT_ID: por el ID del proyecto del grupo de CA.
- SA_EMAIL: por el correo electrónico de la cuenta de servicio que estableciste como tu cuenta de servicio de Cloud Build.

Para otorgar a la cuenta de servicio permisos para acceder a la instancia de Secure Source Manager, ejecuta el siguiente comando.

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

Para otorgar a la cuenta de servicio permisos para leer desde repositorios de Secure Source Manager, ejecuta el siguiente comando.

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

Configura registros de compilación

Cuando especificas tu propia cuenta de servicio para las compilaciones, debes almacenar tus registros de compilación en Cloud Logging o en un bucket de Cloud Storage creado por el usuario. No puedes almacenar tus registros en el bucket de registros predeterminado.

Para almacenar registros de compilación en Cloud Logging, otorga el rol de escritor de registros (roles/logging.logWriter) a tu cuenta de servicio de Cloud Build.

Para obtener más información sobre cómo configurar tus registros de compilación, consulta Configura cuentas de servicio especificadas por el usuario.

Crea una zona de Cloud DNS privada

Para crear una zona de Cloud DNS privada administrada, ejecuta el siguiente comando.

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"

Reemplaza lo siguiente:

ZONE_NAME: por el nombre que deseas darle a la zona administrada.
PROJECT_ID: por el ID del proyecto que Google Cloud deseas usar para la zona de Cloud DNS.
DESCRIPTION: por una descripción de la zona.
INSTANCE_LOCATION: por la ubicación en la que deseas crear tu instancia de Secure Source Manager.

Para obtener más información sobre las zonas de Cloud DNS privadas administradas, consulta Descripción general de Cloud DNS.

Configura tu red de nube privada virtual (VPC)

Reserva un rango de IP que deseas usar para intercambiar tráfico entre la VPC de Secure Source Manager y el grupo privado de Cloud Build.
```
 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
```
Reemplaza lo siguiente:
- CB_PEER_RANGE: por el nombre de la dirección que se creará.
- NETWORK: por el recurso de red en el que se deben reservar las direcciones. Si usas la red predeterminada, el valor es default.
- INSTANCE_PROJECT_ID: por el ID del proyecto de la instancia de Private Service Connect.

Para crear un intercambio de tráfico de VPC con servicenetworking.googleapis.com, ejecuta el siguiente comando.

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

Para crear un dominio DNS con intercambio de tráfico para conectarte con Cloud Build, ejecuta el siguiente comando.
```
gcloud services peered-dns-domains create DNS_PEERING_DOMAIN \
  --network=NETWORK \
  --project=INSTANCE_PROJECT_ID \
  --dns-suffix=INSTANCE_LOCATION.p.sourcemanager.dev.
```
Reemplaza lo siguiente:
- DNS_PEERING_DOMAIN: por el nombre del dominio DNS con intercambio de tráfico que estás creando.
Las zonas de DNS privadas se deben compartir de forma explícita. Para obtener más información sobre cómo compartir zonas de DNS privadas, consulta Comparte zonas DNS privadas con los productores de servicios.

Para exportar rutas de red a Cloud Build, ejecuta el siguiente comando.

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

Para crear el grupo privado de Cloud Build en el mismo Google Cloud proyecto que la instancia de Private Service Connect, ejecuta el siguiente comando.
```
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
```
Aquí, PRIVATE_POOL_ID es el nombre del grupo privado que estás creando. El nombre debe tener entre 1 y 63 caracteres, y los caracteres válidos son [a-zA-Z0-9_-]+.

Para crear un grupo de extremos de red (NEG) de Private Service Connect para el extremo HTTP, ejecuta el siguiente comando:

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

Aquí:

HTTP_NEG_NAME es el nombre del NEG que deseas crear para el extremo HTTP.
HTTP_PSC es el valor del extremo de Private Service Connect HTTP.

Para crear un NEG de Private Service Connect para el extremo SSH, ejecuta el siguiente comando:

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

Aquí:

SSH_NEG_NAME es el nombre del NEG que deseas crear para el extremo SSH.
SSH_PSC es el valor del extremo de Private Service Connect SSH.

Configura un balanceador de cargas interno (ILB) de proxy

No se puede acceder a los extremos desde redes de VPC con intercambio de tráfico. Para acceder a los extremos de Secure Source Manager, debes configurar un balanceador de cargas interno (ILB) L4 para cada extremo. Para obtener más información sobre el acceso a servicios publicados a través de extremos, consulta Información sobre el acceso a servicios publicados a través de extremos.

Para crear una subred de solo proxy para ILBs, ejecuta el siguiente comando.
```
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
```
Aquí:
- ILB_PROXY_SUBNET_NAME es el nombre de la subred que deseas crear.
- CIDR_RANGE es el rango de direcciones IP principal de la subred. Debes usar una máscara de subred de una longitud máxima de 26 para que al menos 64 direcciones IP estén disponibles para los proxies de la región. El tamaño recomendado de la máscara de subred es /23. Si deseas obtener más información sobre las subredes de solo proxy, consulta Subredes de solo proxy para balanceadores de cargas basados en Envoy.

Para crear un ILB L4 para el NEG de conexión HTTP, ejecuta el siguiente comando.

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

Aquí, HTTP_PROXY_ILB es el nombre del ILB que se creará para el extremo HTTP.

Para crear un ILB L4 para el NEG de conexión SSH, ejecuta el siguiente comando.

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

Aquí, SSH_PROXY_ILB es el nombre del ILB que se creará para el extremo SSH.

Registra el NEG de Private Service Connect como el backend de los ILBs

Para registrar el NEG HTTP, ejecuta el siguiente comando.

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

Para registrar el NEG SSH, ejecuta el siguiente comando.

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

Crea proxies TCP de destino para los ILBs

Para crear un proxy TCP de destino para el ILB HTTP, ejecuta el siguiente comando.

gcloud compute target-tcp-proxies create ILB_HTTP_TCP_TARGET_PROXY \
  --backend-service=HTTP_PROXY_ILB \
  --region=INSTANCE_LOCATION \
  --project=INSTANCE_PROJECT_ID

Aquí, ILB_HTTP_TCP_TARGET_PROXY es el nombre del proxy TCP de destino que deseas crear para el ILB HTTP.

Para crear un proxy TCP de destino para el ILB SSH, ejecuta el siguiente comando.

gcloud compute target-tcp-proxies create ILB_SSH_TCP_TARGET_PROXY \
  --backend-service=SSH_PROXY_ILB \
  --region=INSTANCE_LOCATION \
  --project=INSTANCE_PROJECT_ID

Aquí, ILB_SSH_TP_TARGET_PROXY es el nombre del proxy TCP de destino que estás creando para el ILB SSH.

Crea reglas de reenvío para enrutar el tráfico a los ILBs

Para crear una regla de reenvío para enrutar el tráfico al ILB HTTP, ejecuta el siguiente comando.

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

Aquí, HTTP_PROXY_FORWARD es el nombre de la regla de reenvío que estás creando.

Para crear una regla de reenvío para enrutar el tráfico al ILB SSH, ejecuta el siguiente comando.

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

Aquí, SSH_PROXY_FORWARD es el nombre de la regla de reenvío que estás creando.

Crea tus registros DNS privados

Una vez que se configuran las reglas de reenvío, debes registrar registros DNS en tu zona de Cloud DNS privada para cada uno de los nombres de host de la instancia.

Para obtener la dirección IP de tu regla de reenvío HTTP, ejecuta el siguiente comando.
```
gcloud compute forwarding-rules describe HTTP_PROXY_FORWARD \
    --project=INSTANCE_PROJECT_ID \
    --region=INSTANCE_LOCATION
```
Aquí, HTTP_PROXY_FORWARD es el nombre que le diste a la regla de reenvío para HTTP.
Para registrar el nombre de host de la API, ejecuta el siguiente comando.
```
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
```
Reemplaza lo siguiente:
- INSTANCE_ID: por el ID de tu instancia.
- INSTANCE_PROJECT_NUMBER: por el número de proyecto de tu instancia. Google Cloud
- INSTANCE_LOCATION: por la región de tu instancia.
- INSTANCE_PROJECT_ID: por el ID del proyecto de tu instancia. Google Cloud
- ZONE_NAME: por el nombre que le diste a la zona administrada.
- HTTP_LB_IP: es el resultado de gcloud compute forwarding-rules describe HTTP_PROXY_FORWARD.

Para registrar el nombre de host HTTP de Git, ejecuta el siguiente comando.

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

Para registrar el nombre de host HTML de la interfaz web, ejecuta el siguiente comando.

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

Para obtener la dirección IP de tu regla de reenvío SSH, ejecuta el siguiente comando.
```
gcloud compute forwarding-rules describe SSH_PROXY_FORWARD \
    --project=INSTANCE_PROJECT_ID \
    --region=INSTANCE_LOCATION
```
Aquí, SSH_PROXY_FORWARD es el nombre que le diste a la regla de reenvío para SSH.

Para registrar el nombre de host SSH de Git, ejecuta el siguiente comando.

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

Aquí, SSH_LB_IP es el resultado de gcloud compute forwarding-rules describe SSH_PROXY_FORWARD.

Crea un repositorio en tu instancia

Puedes usar un host de bastión para acceder a un repositorio y crearlo en tu instancia de Private Service Connect.

Para crear una VM de host de bastión con el cloud-platform permiso sigue las instrucciones que se indican en Crea una VM host de bastión.
Para crear un repositorio, ejecuta el siguiente comando.
```
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 '{}'
```
Reemplaza lo siguiente:
- INSTANCE_ID: por el nombre de tu instancia de Secure Source Manager.
- PROJECT_NUMBER: por el número de proyecto de tu instancia. Google Cloud
- INSTANCE_LOCATION: por la ubicación de tu instancia.
- REPOSITORY_ID: por el nombre que deseas darle a tu repositorio.
Se crea un repositorio en tu instancia de Private Service Connect.

Prueba el acceso a Secure Source Manager desde Cloud Build

Para confirmar que todo funciona correctamente, puedes usar el siguiente archivo de configuración de compilación para probar la conectividad y extraer el código fuente de Secure Source Manager. El archivo de configuración de compilación supone que usas Cloud Logging para almacenar tus registros de compilación. Si usas un bucket de Cloud Storage creado por el usuario, consulta Ejecuta una compilación con un archivo de configuración para obtener instrucciones sobre cómo editar el archivo de configuración de compilación.

Antes de usar el siguiente archivo YAML, reemplaza lo siguiente:

CA_POOL_NAME: por el nombre del grupo de CA que usaste cuando creaste tu instancia de Private Service Connect.
CA_PROJECT_ID: por el Google Cloud proyecto que usaste para crear el grupo de CA.
INSTANCE_LOCATION: por la ubicación de tu instancia.
INSTANCE_ID: por el nombre de tu instancia.
INSTANCE_PROJECT_NUMBER: por el número de proyecto de tu instancia. Google Cloud
REPOSITORY_ID: por el nombre que le diste a tu repositorio.
SA_PROJECT_ID: por el ID del proyecto de la cuenta de servicio que usas con Cloud Build.
SERVICE_ACCOUNT: por la dirección de correo electrónico de la cuenta de servicio que usas con Cloud Build.

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

¿Qué sigue?

Para automatizar las compilaciones de Secure Source Manager, sigue las instrucciones que se indican en Crea un archivo de activadores.

Conecta Cloud Build a una instancia de Private Service Connect Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.