Esta página foi traduzida pela API Cloud Translation.

Conectar o Cloud Build a uma instância do Private Service Connect

É possível conectar o Cloud Build a uma instância do Private Service Connect do Secure Source Manager usando os pools particulares do Cloud Build.

Antes de começar

Crie uma instância do Secure Source Manager do Private Service Connect.
Se você já tiver configurado os endpoints da sua instância do Private Service Connect, desconecte-os. Para liberar seus endpoints, siga as instruções em Liberar um endereço IPv4 ou IPv6 interno estático.
Enable the Cloud Build, Service Networking, and Compute Engine APIs.
Enable the APIs

Funções exigidas

Para receber as permissões necessárias para conectar o Cloud Build a uma instância do Private Service Connect Secure Source Manager, peça ao administrador para conceder a você o papel do IAM de Administrador do Access Context Manager (roles/accesscontextmanager.policyAdmin) na organização.

Configurar sua conta de serviço

Para seguir o princípio do menor privilégio no Cloud Build, configure o serviço para usar uma conta com privilégios suficientes para executar um build.

Se você não especificar uma conta de serviço, o Cloud Build poderá selecionar automaticamente uma conta para executar builds em seu nome. Essa conta de serviço pode ter permissões desnecessariamente amplas para seu caso de uso, como acesso à sua instância do Secure Source Manager e a todos os repositórios no seu projeto.

Crie uma conta de serviço se você ainda não tiver uma que queira usar.
No console Google Cloud , acesse a página Secure Source Manager Permissões:
Acessar Permissões
Na guia Permissões da conta de serviço, selecione a conta que você quer usar como a conta de serviço do Cloud Build.
Se quiser, selecione Definir como conta de serviço preferencial para pré-preencher sua conta de serviço ao criar novos gatilhos.

Conceder as permissões necessárias à conta de serviço

Conceda à conta de serviço os papéis necessários do Cloud Build para seu caso de uso. Para saber quais papéis do Cloud Build são necessários para diferentes ações do Cloud Build, consulte Configurar o acesso ao Cloud Build.
Para conceder à conta de serviço permissões para recuperar o certificado da CA, execute o seguinte comando.
```
gcloud projects add-iam-policy-binding CA_PROJECT_ID \
  --member=serviceAccount:SA_EMAIL \
  --role=roles/privateca.auditor \
  --condition=None
```
Substitua:
- CA_PROJECT_ID: com o ID do projeto do pool de ACs.
- SA_EMAIL: com o e-mail da conta de serviço que você definiu como sua conta de serviço do Cloud Build.

Para conceder à conta de serviço permissões de acesso à instância do Secure Source Manager, execute o seguinte comando.

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

Para conceder à conta de serviço permissões de leitura dos repositórios do Secure Source Manager, execute o seguinte comando.

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

Configurar registros de build

Ao especificar sua própria conta de serviço para builds, é preciso armazenar os registros de build no Cloud Logging ou em um bucket do Cloud Storage criado pelo usuário. Não é possível armazenar seus registros no bucket de registros padrão.

Para armazenar registros de build no Cloud Logging, conceda o papel Gravador de registros (roles/logging.logWriter) à sua conta de serviço do Cloud Build.

Para mais informações sobre como configurar os registros de build, consulte Configurar contas de serviço especificadas pelo usuário.

Criar uma zona particular do Cloud DNS

Para criar uma zona particular gerenciada do Cloud DNS, execute o seguinte 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"

Substitua:

ZONE_NAME: com o nome que você quer dar à zona gerenciada.
PROJECT_ID: com o ID do projeto Google Cloud que você quer usar para a zona do Cloud DNS.
DESCRIPTION: com uma descrição da zona.
INSTANCE_LOCATION: com o local em que você quer criar a instância do Secure Source Manager.

Para mais informações sobre zonas privadas gerenciadas do Cloud DNS, consulte Visão geral do Cloud DNS.

Configurar a rede de nuvem privada virtual (VPC)

Reserve um intervalo de IP que você quer usar para fazer peering da VPC do Secure Source Manager com o pool particular do 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
```
Substitua:
- CB_PEER_RANGE: com o nome do endereço a ser criado.
- NETWORK: com o recurso de rede em que os endereços precisam ser reservados. Se você estiver usando a rede padrão, o valor será default.
- INSTANCE_PROJECT_ID: com o ID do projeto da instância do Private Service Connect.

Para criar um peering de VPC com servicenetworking.googleapis.com, execute o seguinte comando.

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

Para criar um domínio DNS com peering e se conectar ao Cloud Build, execute o comando a seguir.
```
gcloud services peered-dns-domains create DNS_PEERING_DOMAIN \
  --network=NETWORK \
  --project=INSTANCE_PROJECT_ID \
  --dns-suffix=INSTANCE_LOCATION.p.sourcemanager.dev.
```
Substitua:
- DNS_PEERING_DOMAIN: com o nome do domínio DNS com peering que você está criando.
As zonas particulares de DNS precisam ser compartilhadas explicitamente. Para mais informações sobre como compartilhar zonas de DNS particulares, consulte Compartilhar zonas de DNS particulares com produtores de serviço.

Para exportar rotas de rede para o Cloud Build, execute o seguinte 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 criar o pool privado do Cloud Build no mesmo projeto Google Cloud da instância do Private Service Connect, execute o seguinte 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
```
Em que PRIVATE_POOL_ID é o nome do pool particular que você está criando. O nome precisa ter de 1 a 63 caracteres, e os caracteres válidos são [a-zA-Z0-9_-]+.

Para criar um grupo de endpoints de rede (NEG) do Private Service Connect para o endpoint HTTP, execute o seguinte 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

Em que:

HTTP_NEG_NAME é o nome do NEG que você quer criar para o endpoint HTTP.
HTTP_PSC é o valor do endpoint HTTP do Private Service Connect.

Para criar um NEG do Private Service Connect para o endpoint SSH, execute o seguinte 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

Em que:

SSH_NEG_NAME é o nome do NEG que você quer criar para o endpoint SSH.
SSH_PSC é o valor do endpoint do Private Service Connect SSH.

Configurar um balanceador de carga interno (ILB) de proxy

Os endpoints não podem ser acessados em redes VPC com peering. Para acessar os endpoints do Secure Source Manager, configure um balanceador de carga interno (ILB) L4 para cada endpoint. Para mais informações sobre como acessar serviços publicados por endpoints, consulte Sobre como acessar serviços publicados por endpoints.

Para criar uma sub-rede somente proxy para ILBs, execute o comando a seguir.
```
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
```
Em que:
- ILB_PROXY_SUBNET_NAME é o nome da sub-rede a ser criada.
- CIDR_RANGE é o intervalo de endereços IP principal da sub-rede; Use uma máscara de sub-rede de até 26 de comprimento para que ao menos 64 endereços IP estejam disponíveis para os proxies na região. O comprimento recomendado da máscara de sub-rede é /23. Para mais informações sobre sub-redes somente proxy, consulte Sub-redes somente proxy para balanceadores de carga baseados no Envoy.

Para criar um ILB de camada 4 para o NEG de conexão HTTP, execute o comando a seguir.

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

Em que HTTP_PROXY_ILB é o nome do ILB a ser criado para o endpoint HTTP.

Para criar um ILB de camada 4 para o NEG de conexão SSH, execute o seguinte comando:

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

em que SSH_PROXY_ILB é o nome do ILB a ser criado para o endpoint SSH.

Registrar o NEG do Private Service Connect como o back-end dos ILBs

Para registrar o NEG HTTP, execute o seguinte 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 o NEG do SSH, execute o seguinte 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

Criar proxies TCP de destino para os ILBs

Para criar um proxy TCP de destino para o ILB HTTP, execute o seguinte comando:

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

Em que ILB_HTTP_TCP_TARGET_PROXY é o nome do proxy TCP de destino que você quer criar para o ILB HTTP.

Para criar um proxy TCP de destino para o ILB SSH, execute o seguinte comando.

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

Em que ILB_SSH_TP_TARGET_PROXY é o nome do proxy TCP de destino que você está criando para o ILB SSH.

Criar regras de encaminhamento para rotear o tráfego para os ILBs

Para criar uma regra de encaminhamento para rotear o tráfego para o ILB HTTP, execute o comando a seguir.

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

Em que HTTP_PROXY_FORWARD é o nome da regra de encaminhamento que você está criando.

Para criar uma regra de encaminhamento para rotear o tráfego para o ILB SSH, execute o comando a seguir.

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

Em que SSH_PROXY_FORWARD é o nome da regra de encaminhamento que você está criando.

Criar registros DNS particulares

Depois que as regras de encaminhamento forem configuradas, registre os registros DNS na sua zona privada do Cloud DNS para cada um dos nomes de host da instância.

Para receber o endereço IP da sua regra de encaminhamento HTTP, execute o seguinte comando.
```
gcloud compute forwarding-rules describe HTTP_PROXY_FORWARD \
    --project=INSTANCE_PROJECT_ID \
    --region=INSTANCE_LOCATION
```
Em que HTTP_PROXY_FORWARD é o nome que você deu à regra de encaminhamento para HTTP.
Para registrar o nome do host da API, execute o seguinte 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
```
Substitua:
- INSTANCE_ID: com o ID da sua instância.
- INSTANCE_PROJECT_NUMBER: com o número do projeto Google Cloud da instância.
- INSTANCE_LOCATION: com a região da instância.
- INSTANCE_PROJECT_ID: com o ID do projeto Google Cloud da sua instância.
- ZONE_NAME: com o nome que você deu à zona gerenciada.
- HTTP_LB_IP: é a saída de gcloud compute forwarding-rules describe HTTP_PROXY_FORWARD.

Para registrar o nome do host HTTP do Git, execute o seguinte 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 o nome do host HTML da interface da Web, execute o seguinte 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 receber o endereço IP da sua regra de encaminhamento de SSH, execute o seguinte comando.
```
gcloud compute forwarding-rules describe SSH_PROXY_FORWARD \
    --project=INSTANCE_PROJECT_ID \
    --region=INSTANCE_LOCATION
```
Em que SSH_PROXY_FORWARD é o nome que você deu à regra de encaminhamento para SSH.

Para registrar o nome do host SSH do Git, execute o seguinte 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

Em que SSH_LB_IP é a saída de gcloud compute forwarding-rules describe SSH_PROXY_FORWARD.

Criar um repositório na sua instância

É possível usar um bastion host para acessar e criar um repositório na sua instância do Private Service Connect.

Crie uma VM do Bastion Host com o escopo cloud-platform seguindo as instruções em Criar uma VM do Bastion Host.
Crie um repositório executando o seguinte 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 '{}'
```
Substitua:
- INSTANCE_ID: com o nome da sua instância do Secure Source Manager.
- PROJECT_NUMBER: com o número do projeto Google Cloud da instância.
- INSTANCE_LOCATION: com o local da instância.
- REPOSITORY_ID: com o nome que você quer dar ao repositório.
Um repositório é criado na sua instância do Private Service Connect.

Testar o acesso ao Secure Source Manager no Cloud Build

Para confirmar se tudo está funcionando corretamente, use o seguinte arquivo de configuração de build para testar a conectividade e extrair o código-fonte do Secure Source Manager. O arquivo de configuração da versão pressupõe que você está usando o Cloud Logging para armazenar os registros de build. Se você estiver usando um bucket do Cloud Storage criado pelo usuário, consulte Executar um build usando um arquivo de configuração para instruções sobre como editar o arquivo de configuração do build.

Antes de usar o arquivo YAML a seguir, substitua:

CA_POOL_NAME: com o nome do pool de ACs que você usou ao criar a instância do Private Service Connect.
CA_PROJECT_ID: com o projeto Google Cloud usado para criar o pool de ACs.
INSTANCE_LOCATION: com o local da instância.
INSTANCE_ID: com o nome da instância.
INSTANCE_PROJECT_NUMBER: com o número do projeto Google Cloud da instância.
REPOSITORY_ID: com o nome que você deu ao repositório.
SA_PROJECT_ID: com o ID do projeto da conta de serviço que você está usando com o Cloud Build.
SERVICE_ACCOUNT: com o endereço de e-mail da conta de serviço que você está usando com o 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

A seguir

Para automatizar builds do Secure Source Manager, siga as instruções em Criar um arquivo de acionadores.

Conectar o Cloud Build a uma instância do Private Service Connect Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.