Cette page a été traduite par l'API Cloud Translation.

Connecter Cloud Build à une instance Private Service Connect

Vous pouvez connecter Cloud Build à une instance Secure Source Manager Private Service Connect à l'aide de pools privés Cloud Build.

Avant de commencer

Créez une instance Secure Source Manager Private Service Connect.
Si vous avez déjà configuré les points de terminaison de votre instance Private Service Connect, vous devez les dissocier. Pour libérer vos points de terminaison, suivez les instructions de la section Libérer une adresse IPv4 ou IPv6 interne statique.
Enable the Cloud Build, Service Networking, and Compute Engine APIs.
Enable the APIs

Rôles requis

Pour obtenir les autorisations nécessaires pour connecter Cloud Build à une instance Secure Source Manager Private Service Connect, demandez à votre administrateur de vous accorder le rôle IAM Administrateur Access Context Manager (roles/accesscontextmanager.policyAdmin) sur l'organisation.

Configurer votre compte de service

Pour suivre le principe du moindre privilège dans Cloud Build, vous pouvez configurer Cloud Build pour qu'il utilise un compte de service disposant des droits suffisants pour exécuter une compilation.

Si vous ne spécifiez pas de compte de service, Cloud Build peut en sélectionner un automatiquement pour exécuter des compilations en votre nom. Ce compte de service peut disposer d'autorisations inutilement étendues pour votre cas d'utilisation, comme l'accès à votre instance Secure Source Manager et à tous les dépôts de votre projet.

Créez un compte de service si vous n'en avez pas déjà un que vous souhaitez utiliser.
Dans la console Google Cloud , accédez à la page Autorisations de Secure Source Manager :
Accéder à Autorisations
Dans l'onglet Autorisations du compte de service, sélectionnez le compte de service que vous souhaitez utiliser comme compte de service Cloud Build.
Vous pouvez également sélectionner Définir comme compte de service préféré pour préremplir votre compte de service lorsque vous créez des déclencheurs.

Accorder les autorisations requises au compte de service

Attribuez au compte de service les rôles Cloud Build requis pour votre cas d'utilisation. Pour savoir quels rôles Cloud Build sont requis pour différentes actions Cloud Build, consultez Configurer l'accès à Cloud Build.
Pour accorder au compte de service les autorisations nécessaires pour récupérer le certificat de l'autorité de certification, exécutez la commande suivante.
```
gcloud projects add-iam-policy-binding CA_PROJECT_ID \
  --member=serviceAccount:SA_EMAIL \
  --role=roles/privateca.auditor \
  --condition=None
```
Remplacez les éléments suivants :
- CA_PROJECT_ID : ID du projet du pool d'autorités de certification.
- SA_EMAIL : avec l'adresse e-mail du compte de service que vous avez défini comme compte de service Cloud Build.

Pour accorder au compte de service les autorisations d'accès à l'instance Secure Source Manager, exécutez la commande suivante.

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

Pour accorder au compte de service les autorisations de lecture des dépôts Secure Source Manager, exécutez la commande suivante.

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

Configurer les journaux de compilation

Lorsque vous spécifiez votre propre compte de service pour les compilations, vous devez stocker vos journaux de compilation dans Cloud Logging ou dans un bucket Cloud Storage créé par l'utilisateur. Vous ne pouvez pas stocker vos journaux dans le bucket de journaux par défaut.

Pour stocker des journaux de compilation dans Cloud Logging, attribuez le rôle Rédacteur de journaux (roles/logging.logWriter) à votre compte de service Cloud Build.

Pour savoir comment configurer vos journaux de compilation, consultez Configurer des comptes de service spécifiés par l'utilisateur.

Créer une zone Cloud DNS privée

Pour créer une zone Cloud DNS privée gérée, exécutez la commande suivante.

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"

Remplacez les éléments suivants :

ZONE_NAME : nom que vous souhaitez attribuer à la zone gérée.
PROJECT_ID : avec l'ID du projet Google Cloud que vous souhaitez utiliser pour la zone Cloud DNS.
DESCRIPTION : description de la zone.
INSTANCE_LOCATION : emplacement où vous souhaitez créer votre instance Secure Source Manager.

Pour en savoir plus sur les zones Cloud DNS privées gérées, consultez la présentation de Cloud DNS.

Configurer votre réseau de cloud privé virtuel (VPC)

Réservez une plage d'adresses IP que vous souhaitez utiliser pour appairer le VPC Secure Source Manager avec le pool privé 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
```
Remplacez les éléments suivants :
- CB_PEER_RANGE : nom de l'adresse à créer.
- NETWORK : avec la ressource réseau dans laquelle les adresses doivent être réservées. Si vous utilisez le réseau par défaut, la valeur est default.
- INSTANCE_PROJECT_ID : avec l'ID du projet d'instance Private Service Connect.

Pour créer un appairage de VPC avec servicenetworking.googleapis.com, exécutez la commande suivante.

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

Pour créer un domaine DNS appairé afin de vous connecter à Cloud Build, exécutez la commande suivante.
```
gcloud services peered-dns-domains create DNS_PEERING_DOMAIN \
  --network=NETWORK \
  --project=INSTANCE_PROJECT_ID \
  --dns-suffix=INSTANCE_LOCATION.p.sourcemanager.dev.
```
Remplacez les éléments suivants :
- DNS_PEERING_DOMAIN : nom du domaine DNS appairé que vous créez.
Les zones DNS privées doivent être partagées de manière explicite. Pour en savoir plus sur le partage de zones DNS privées, consultez Partager des zones DNS privées avec des producteurs de services.

Pour exporter les routes réseau vers Cloud Build, exécutez la commande suivante.

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

Pour créer le pool privé Cloud Build dans le même projet Google Cloudque l'instance Private Service Connect, exécutez la commande suivante.
```
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
```
Où PRIVATE_POOL_ID est le nom du pool privé que vous créez. Le nom doit comporter entre 1 et 63 caractères, et les caractères valides sont [a-zA-Z0-9_-]+.
Pour créer un groupe de points de terminaison du réseau (NEG) Private Service Connect pour le point de terminaison HTTP, exécutez la commande suivante :
```
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
```
Où :
- HTTP_NEG_NAME correspond au nom du NEG que vous souhaitez créer pour le point de terminaison HTTP.
- HTTP_PSC correspond à la valeur du point de terminaison HTTP Private Service Connect.
Pour créer un NEG Private Service Connect pour le point de terminaison SSH, exécutez la commande suivante :
```
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
```
Où :
- SSH_NEG_NAME est le nom du NEG que vous souhaitez créer pour le point de terminaison SSH.
- SSH_PSC correspond à la valeur du point de terminaison SSH Private Service Connect.

Configurer un équilibreur de charge interne (ILB) de proxy

Les points de terminaison ne sont pas accessibles à partir des réseaux VPC appairés. Pour accéder aux points de terminaison Secure Source Manager, vous devez configurer un équilibreur de charge interne (ILB) de niveau 4 pour chaque point de terminaison. Pour en savoir plus sur l'accès aux services publiés via des points de terminaison, consultez À propos de l'accès aux services publiés via des points de terminaison.

Pour créer un sous-réseau proxy réservé aux équilibreurs de charge internes, exécutez la commande suivante.
```
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
```
Où :
- ILB_PROXY_SUBNET_NAME correspond au nom du sous-réseau à créer.
- CIDR_RANGE correspond à la plage d'adresses IP principale du sous-réseau. Vous devez utiliser un masque de sous-réseau ne dépassant pas 26 afin qu'au moins 64 adresses IP soient disponibles pour les proxys de la région. La longueur de masque de sous-réseau recommandée est /23. Pour en savoir plus sur les sous-réseaux proxy réservés, consultez Sous-réseaux proxy réservés pour les équilibreurs de charge basés sur Envoy.
Pour créer un équilibreur de charge d'adresse IP interne de couche 4 pour le NEG de connexion HTTP, exécutez la commande suivante.
```
gcloud compute backend-services create HTTP_PROXY_ILB \
  --project=INSTANCE_PROJECT_ID \
  --region=INSTANCE_LOCATION \
  --load-balancing-scheme=INTERNAL_MANAGED
```
où HTTP_PROXY_ILB est le nom de l'ILB à créer pour le point de terminaison HTTP.
Pour créer un équilibreur de charge interne de couche 4 pour le NEG de connexion SSH, exécutez la commande suivante.
```
gcloud compute backend-services create SSH_PROXY_ILB \
    --project=INSTANCE_PROJECT_ID \
    --region=INSTANCE_LOCATION \
    --load-balancing-scheme=INTERNAL_MANAGED
```
où SSH_PROXY_ILB est le nom de l'ILB à créer pour le point de terminaison SSH.

Enregistrer le NEG Private Service Connect comme backend des équilibreurs de charge internes

Pour enregistrer le NEG HTTP, exécutez la commande suivante.

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

Pour enregistrer le NEG SSH, exécutez la commande suivante.

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

Créer des proxys TCP cibles pour les équilibreurs de charge internes

Pour créer un proxy TCP cible pour l'équilibreur de charge HTTP interne, exécutez la commande suivante.
```
gcloud compute target-tcp-proxies create ILB_HTTP_TCP_TARGET_PROXY \
  --backend-service=HTTP_PROXY_ILB \
  --region=INSTANCE_LOCATION \
  --project=INSTANCE_PROJECT_ID
```
où ILB_HTTP_TCP_TARGET_PROXY correspond au nom du proxy TCP cible que vous souhaitez créer pour l'équilibreur de charge interne HTTP.
Pour créer un proxy TCP cible pour l'équilibreur de charge interne SSH, exécutez la commande suivante.
```
gcloud compute target-tcp-proxies create ILB_SSH_TCP_TARGET_PROXY \
  --backend-service=SSH_PROXY_ILB \
  --region=INSTANCE_LOCATION \
  --project=INSTANCE_PROJECT_ID
```
Où ILB_SSH_TP_TARGET_PROXY est le nom du proxy TCP cible que vous créez pour l'équilibreur de charge interne SSH.

Créer des règles de transfert pour acheminer le trafic vers les équilibreurs de charge internes

Pour créer une règle de transfert permettant de router le trafic vers l'équilibreur de charge interne HTTP, exécutez la commande suivante.

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

HTTP_PROXY_FORWARD correspond au nom de la règle de transfert que vous créez.

Pour créer une règle de transfert permettant de router le trafic vers l'équilibreur de charge interne SSH, exécutez la commande suivante.

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

SSH_PROXY_FORWARD correspond au nom de la règle de transfert que vous créez.

Créer vos enregistrements DNS privés

Une fois les règles de transfert configurées, vous devez enregistrer des enregistrements DNS dans votre zone Cloud DNS privée pour chacun des noms d'hôte de l'instance.

Pour obtenir l'adresse IP de votre règle de transfert HTTP, exécutez la commande suivante.
```
gcloud compute forwarding-rules describe HTTP_PROXY_FORWARD \
    --project=INSTANCE_PROJECT_ID \
    --region=INSTANCE_LOCATION
```
Où HTTP_PROXY_FORWARD est le nom que vous avez donné à la règle de transfert pour HTTP.
Pour enregistrer le nom d'hôte de l'API, exécutez la commande suivante.
```
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
```
Remplacez les éléments suivants :
- INSTANCE_ID : par l'ID de votre instance.
- INSTANCE_PROJECT_NUMBER : avec le numéro de projet Google Cloudde votre instance.
- INSTANCE_LOCATION : par la région de votre instance.
- INSTANCE_PROJECT_ID : avec l'ID de projet Google Cloudde votre instance.
- ZONE_NAME : avec le nom que vous avez donné à la zone gérée.
- HTTP_LB_IP : sortie de gcloud compute forwarding-rules describe HTTP_PROXY_FORWARD.

Pour enregistrer le nom d'hôte HTTP Git, exécutez la commande suivante.

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

Pour enregistrer le nom d'hôte HTML de l'interface Web, exécutez la commande suivante.

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

Pour obtenir l'adresse IP de votre règle de transfert SSH, exécutez la commande suivante.
```
gcloud compute forwarding-rules describe SSH_PROXY_FORWARD \
    --project=INSTANCE_PROJECT_ID \
    --region=INSTANCE_LOCATION
```
Où SSH_PROXY_FORWARD est le nom que vous avez donné à la règle de transfert pour SSH.

Pour enregistrer le nom d'hôte SSH Git, exécutez la commande suivante.

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

Où SSH_LB_IP est la sortie de gcloud compute forwarding-rules describe SSH_PROXY_FORWARD.

Créer un dépôt dans votre instance

Vous pouvez utiliser un hôte bastion pour accéder à un dépôt et en créer un dans votre instance Private Service Connect.

Créez une VM d'hôte bastion avec le champ d'application cloud-platform en suivant les instructions de la section Créer une VM d'hôte bastion.
Créez un dépôt en exécutant la commande suivante.
```
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 '{}'
```
Remplacez les éléments suivants :
- INSTANCE_ID par le nom de votre instance Secure Source Manager.
- PROJECT_NUMBER : avec le numéro de projet Google Cloud de votre instance.
- INSTANCE_LOCATION : emplacement de votre instance.
- REPOSITORY_ID par le nom que vous souhaitez attribuer à votre dépôt.
Un dépôt est créé dans votre instance Private Service Connect.

Tester l'accès à Secure Source Manager depuis Cloud Build

Pour vérifier que tout fonctionne correctement, vous pouvez utiliser le fichier de configuration de compilation suivant pour tester la connectivité et extraire le code source de Secure Source Manager. Le fichier de configuration de compilation suppose que vous utilisez Cloud Logging pour stocker vos journaux de compilation. Si vous utilisez un bucket Cloud Storage créé par l'utilisateur, consultez Exécuter une compilation à l'aide d'un fichier de configuration pour obtenir des instructions sur la modification du fichier de configuration de compilation.

Avant d'utiliser le fichier YAML suivant, remplacez les éléments ci-dessous :

CA_POOL_NAME : avec le nom du pool d'autorités de certification que vous avez utilisé lorsque vous avez créé votre instance Private Service Connect.
CA_PROJECT_ID : avec le Google Cloud projet que vous avez utilisé pour créer le pool d'autorités de certification.
INSTANCE_LOCATION : emplacement de votre instance.
INSTANCE_ID par le nom de votre instance.
INSTANCE_PROJECT_NUMBER : avec le numéro de projet Google Cloud de votre instance.
REPOSITORY_ID par le nom que vous avez donné à votre dépôt.
SA_PROJECT_ID par l'ID du projet du compte de service que vous utilisez avec Cloud Build.
SERVICE_ACCOUNT : avec l'adresse e-mail du compte de service que vous utilisez avec 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

Étapes suivantes

Pour automatiser les compilations à partir de Secure Source Manager, suivez les instructions de la section Créer un fichier de déclencheurs.

Connecter Cloud Build à une instance Private Service Connect Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.