Se usó la API de Cloud Translation para traducir esta página.

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.

Antes de comenzar

Crea una instancia de Secure Source Manager con Private Service Connect.
Si ya configuraste 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.
Enable the Cloud Build, Service Networking, and Compute Engine APIs.
Enable the APIs

Roles requeridos

Para obtener los permisos que necesitas para conectar Cloud Build a una instancia de Secure Source Manager de Private Service Connect, pídele a tu administrador que te otorgue el rol de administrador de Access Context Manager (roles/accesscontextmanager.policyAdmin) de IAM 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 que use 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 para ejecutar compilaciones en tu nombre. Esta cuenta de servicio podría tener permisos innecesariamente amplios para tu caso de uso, como 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 consola de Google Cloud , ve a la página de Secure Source Manager Permisos:
Ir a Permisos
En la pestaña Permisos de la cuenta de servicio, selecciona la cuenta de servicio que deseas usar como cuenta de servicio de Cloud Build.
De manera opcional, selecciona Establecer como cuenta de servicio preferida 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 se requieren para diferentes acciones de Cloud Build, consulta Configura el acceso a Cloud Build.
Para otorgar permisos a la cuenta de servicio para recuperar el certificado de la CA, 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: con el ID del proyecto del proyecto del grupo de AC.
- SA_EMAIL: Con el correo electrónico de la cuenta de servicio que configuraste como tu cuenta de servicio de Cloud Build.

Para otorgar permisos a la cuenta de servicio 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 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 privada de Cloud DNS

Para crear una zona privada administrada de Cloud DNS, 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: con el nombre que deseas darle a la zona administrada.
PROJECT_ID: con el ID del proyecto de Google Cloud proyecto que deseas usar para la zona de Cloud DNS.
DESCRIPTION: con una descripción de la zona.
INSTANCE_LOCATION: Es la ubicación en la que deseas crear tu instancia de Secure Source Manager.

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

Configura tu red de nube privada virtual (VPC)

Reserva un rango de IP que desees usar para interconectar la VPC de Secure Source Manager con 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: Con el nombre de la dirección que se creará.
- NETWORK: con el recurso de red en el que se deben reservar las direcciones. Si usas la red predeterminada, el valor es default.
- INSTANCE_PROJECT_ID: con el ID del proyecto de la instancia de Private Service Connect.

Para crear un intercambio de tráfico entre VPCs 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: Con el nombre del dominio DNS con intercambio de tráfico que estás creando.
Las zonas DNS privadas se deben compartir de forma explícita. Para obtener más información sobre cómo compartir zonas 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 proyecto Google Cloudque 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 crearás. 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 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

Aquí:

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

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

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

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 de 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) de L4 para cada extremo. Para obtener más información sobre el acceso a los servicios publicados a través de extremos, consulta Información sobre el acceso a los servicios publicados a través de extremos.

Para crear una subred de solo proxy para los ILB, 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 de 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 de nivel 4 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 de SSH.

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

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 de 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 ILB

Para crear un proxy TCP de destino para el ILB de 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 de 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
```
En el ejemplo anterior, ILB_SSH_TP_TARGET_PROXY es el nombre del proxy TCP de destino que crearás para el ILB de SSH.

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

Para crear una regla de reenvío que enrute 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

En este comando, HTTP_PROXY_FORWARD es el nombre de la regla de reenvío que crearás.

Para crear una regla de reenvío que enrute el tráfico al ILB de 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

En el ejemplo anterior, SSH_PROXY_FORWARD es el nombre de la regla de reenvío que crearás.

Crea tus registros de DNS privado

Una vez que se configuran las reglas de reenvío, debes registrar los registros DNS en tu zona privada de Cloud DNS 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 asignaste 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: con el ID de tu instancia.
- INSTANCE_PROJECT_NUMBER: con el número de proyecto de tu instancia de Google Cloud
- INSTANCE_LOCATION: Con la región de tu instancia.
- INSTANCE_PROJECT_ID: con el ID del proyecto Google Cloudde tu instancia
- ZONE_NAME: con 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 de 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 asignaste a la regla de reenvío para SSH.

Para registrar el nombre de host de 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.

Crea una VM de host de bastión con el alcance cloud-platform siguiendo las instrucciones en Crea una VM de host de bastión.
Ejecuta el siguiente comando para crear un repositorio.
```
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: con el nombre de tu instancia de Secure Source Manager.
- PROJECT_NUMBER: con el número de proyecto de tu instancia de Google Cloud
- INSTANCE_LOCATION: Con la ubicación de tu instancia
- REPOSITORY_ID: con 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: con el nombre del grupo de CA que usaste cuando creaste tu instancia de Private Service Connect
CA_PROJECT_ID: con el proyecto Google Cloud que usaste para crear el grupo de CA.
INSTANCE_LOCATION: Con la ubicación de tu instancia
INSTANCE_ID: con el nombre de tu instancia
INSTANCE_PROJECT_NUMBER: con el número de proyecto de tu instancia de Google Cloud
REPOSITORY_ID: con el nombre que le asignaste a tu repositorio.
SA_PROJECT_ID por el ID del proyecto de la cuenta de servicio que usas con Cloud Build.
SERVICE_ACCOUNT: con 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 desde Secure Source Manager, sigue las instrucciones 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.