Esta página se ha traducido con Cloud Translation API.

Conectar Cloud Build a una instancia de Private Service Connect

Puedes conectar Cloud Build a una instancia de Private Service Connect de Secure Source Manager mediante grupos privados de Cloud Build.

Antes de empezar

Crea una instancia de Secure Source Manager de Private Service Connect.
Si ya has configurado los endpoints de tu instancia de Private Service Connect, debes desconectarlos. Para liberar tus endpoints, sigue las instrucciones que se indican en Liberar una dirección IPv4 o IPv6 interna estática.
Enable the Cloud Build, Service Networking, and Compute Engine APIs.
Roles required to enable APIs
To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.
Enable the APIs

Roles obligatorios

Para obtener los permisos que necesitas para conectar Cloud Build a una instancia de Secure Source Manager de Private Service Connect, pide a tu administrador que te conceda el rol Administrador de Access Context Manager (roles/accesscontextmanager.policyAdmin) de gestión de identidades y accesos en la organización.

Configurar tu cuenta de servicio

Para seguir el principio de mínimos accesos 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, Cloud Build puede seleccionar automáticamente una cuenta de servicio para ejecutar compilaciones en tu nombre. Esta cuenta de servicio puede tener permisos innecesariamente amplios para tu caso práctico, 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 Google Cloud consola, ve a la página Secure Source Manager Permisos:
Ve a Permisos.
En la pestaña Permisos de cuenta de servicio, selecciona la cuenta de servicio que quieras usar como cuenta de servicio de Cloud Build.
También puedes seleccionar Definir como cuenta de servicio preferida para rellenar automáticamente tu cuenta de servicio cuando crees nuevos activadores.

Conceder los permisos necesarios a la cuenta de servicio

Concede a la cuenta de servicio los roles de Cloud Build necesarios para tu caso de uso. Para obtener información sobre los roles de Cloud Build necesarios para realizar diferentes acciones de Cloud Build, consulta el artículo sobre cómo configurar el acceso a Cloud Build.
Para conceder a la cuenta de servicio los permisos para obtener el certificado de la autoridad certificadora, ejecuta el siguiente comando.
```
gcloud projects add-iam-policy-binding CA_PROJECT_ID \
  --member=serviceAccount:SA_EMAIL \
  --role=roles/privateca.auditor \
  --condition=None
```
Haz los cambios siguientes:
- CA_PROJECT_ID: con el ID de proyecto del proyecto del grupo de CAs.
- SA_EMAIL: con el correo de la cuenta de servicio que hayas configurado como cuenta de servicio de Cloud Build.

Para conceder 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 conceder 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

Configurar registros de compilación

Cuando especifiques tu propia cuenta de servicio para las compilaciones, deberás almacenar los registros de compilación en Cloud Logging o en un segmento de Cloud Storage creado por el usuario. No puedes almacenar tus registros en el segmento de registros predeterminado.

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

Para obtener más información sobre cómo configurar los registros de compilación, consulta el artículo Configurar cuentas de servicio especificadas por los usuarios.

Crear una zona de Cloud DNS privada

Para crear una zona de Cloud DNS privada gestionada, 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"

Haz los cambios siguientes:

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

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

Configurar tu red de nube privada virtual (VPC)

Reserva un intervalo de IPs que quieras usar para emparejar 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
```
Haz los cambios siguientes:
- CB_PEER_RANGE por el nombre de la dirección que quieras crear.
- NETWORK: con el recurso de red en el que se deben reservar las direcciones. Si usa 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 emparejamiento 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 emparejado que se conecte 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.
```
Haz los cambios siguientes:
- DNS_PEERING_DOMAIN: con el nombre del dominio DNS emparejado que vas a crear.
Las zonas de DNS privadas deben compartirse explícitamente. Para obtener más información sobre cómo compartir zonas de DNS privadas, consulta Compartir zonas de DNS privadas con 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 que la instancia de Private Service Connect, ejecuta el siguiente comando. Google Cloud
```
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
```
Donde PRIVATE_POOL_ID es el nombre del grupo privado que vas a crear. El nombre debe tener entre 1 y 63 caracteres, y los caracteres válidos son [a-zA-Z0-9_-]+.

Para crear un grupo de endpoints de red (NEG) de Private Service Connect para el endpoint 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

Donde:

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

Para crear un NEG de Private Service Connect para el endpoint 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

Donde:

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

Configurar un balanceador de carga interno (ILB) de proxy

No se puede acceder a los endpoints desde redes de VPC emparejadas. Para acceder a los endpoints de Secure Source Manager, debes configurar un balanceador de carga interno (ILB) de nivel 4 para cada endpoint. Para obtener más información sobre cómo acceder a los servicios publicados a través de los endpoints, consulta Acerca del acceso a servicios publicados a través de endpoints.

Para crear una subred de solo proxy para balanceadores de carga internos, 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
```
Donde:
- ILB_PROXY_SUBNET_NAME es el nombre de la subred que se va a crear.
- CIDR_RANGE es el intervalo de direcciones IP principal de la subred. Debes usar una máscara de subred de 26 o menos para que haya al menos 64 direcciones IP disponibles para proxies en la región. La longitud de máscara de subred recomendada es /23. Para obtener más información sobre las subredes de solo proxy, consulta Subredes de solo proxy para balanceadores de carga basados en Envoy.
Para crear un balanceador de carga interno de nivel 4 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
```
Donde HTTP_PROXY_ILB es el nombre del ILB que se va a crear para el endpoint 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
```
Donde SSH_PROXY_ILB es el nombre del balanceador de carga interno que se va a crear para el endpoint de SSH.

Registrar el NEG de Private Service Connect como 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 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

Crear 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
```
Donde ILB_HTTP_TCP_TARGET_PROXY es el nombre del proxy TCP de destino que quieres crear para el balanceador de carga interno 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
```
Donde ILB_SSH_TP_TARGET_PROXY es el nombre del proxy TCP de destino que estás creando para el balanceador de carga interno SSH.

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

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

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

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

Donde SSH_PROXY_FORWARD es el nombre de la regla de reenvío que vas a crear.

Crea tus registros DNS privados

Una vez que hayas configurado 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
```
Donde HTTP_PROXY_FORWARD es el nombre que le has dado a la regla de reenvío de 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
```
Haz los cambios siguientes:
- INSTANCE_ID por tu ID de instancia.
- INSTANCE_PROJECT_NUMBER: con el número de proyecto de tu instancia Google Cloud.
- INSTANCE_LOCATION: con la región de tu instancia.
- INSTANCE_PROJECT_ID: con el ID de proyecto de tu instancia. Google Cloud
- ZONE_NAME: con el nombre que le has dado a la zona gestionada.
- 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
```
Donde SSH_PROXY_FORWARD es el nombre que le has dado a la regla de reenvío de 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

Donde SSH_LB_IP es el resultado de gcloud compute forwarding-rules describe SSH_PROXY_FORWARD.

Crear un repositorio en tu instancia

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

Crea una VM de host bastion con el cloud-platform ámbito siguiendo las instrucciones de Crear una VM de host bastion.
Crea un repositorio ejecutando 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 '{}'
```
Haz los cambios siguientes:
- INSTANCE_ID: con el nombre de tu instancia de Secure Source Manager.
- PROJECT_NUMBER: con el número de proyecto de tu instancia Google Cloud .
- INSTANCE_LOCATION con la ubicación de tu instancia.
- REPOSITORY_ID: con el nombre que quieras dar al repositorio.
Se crea un repositorio en tu instancia de Private Service Connect.

Probar el acceso a Secure Source Manager desde Cloud Build

Para confirmar que todo funciona correctamente, puede 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 da por hecho que usas Cloud Logging para almacenar los registros de compilación. Si usas un segmento de Cloud Storage creado por un usuario, consulta Ejecutar una compilación con un archivo de configuración para obtener instrucciones sobre cómo editar el archivo de configuración de la compilación.

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

CA_POOL_NAME: con el nombre del grupo de ACs que usaste al crear tu instancia de Private Service Connect.
CA_PROJECT_ID: con el Google Cloud proyecto que has usado para crear el grupo de autoridades de certificación.
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 Google Cloud .
REPOSITORY_ID: con el nombre que le hayas dado al repositorio.
SA_PROJECT_ID: con el ID de proyecto de la cuenta de servicio que estás usando con Cloud Build.
SERVICE_ACCOUNT: con la dirección de correo 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

Siguientes pasos

Para automatizar las compilaciones de Secure Source Manager, siga las instrucciones de Crear un archivo de activadores.

Conectar Cloud Build a una instancia de Private Service Connect Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.