Esta página foi traduzida pela API Cloud Translation.

Acessar recursos externos em uma rede privada usando um IP externo estático

Nesta página, explicamos como configurar seus pools particulares para acessar recursos externos usando um IP externo estático.

Para seguir as instruções passo a passo desta tarefa diretamente no console do Google Cloud, clique em Orientação:

Orientações

Antes de começar

Enable the Cloud Build, Compute Engine, and Service Networking APIs.
Enable the APIs

Para receber as permissões necessárias para configurar uma conexão particular, peça ao administrador para conceder a você o papel do IAM de Administrador de rede do Compute Engine (roles/compute.networkAdmin) no projeto da Cloud em que a rede VPC está. Para mais informações sobre como conceder papéis, consulte Gerenciar acesso.
Para usar os comandos do gcloud nesta página, instale a Google Cloud CLI.

Observação: se você já instalou a CLI gcloud, execute gcloud components update para verificar se você tem a versão mais recente disponível.

Crie uma rede VPC

Console

Para criar uma rede VPC usando o console do Google Cloud, siga estas etapas:

Abra a página Redes VPC no console do Google Cloud.

Acessar redes VPC
Clique em Criar rede VPC para criar uma nova rede.

Você verá a página Criar uma rede VPC.
Digite um Nome para a rede.
Em Modo de criação da sub-rede, selecione Automático.
Se quiser personalizar ainda mais outros campos, consulte Criar e gerenciar redes VPC. Caso contrário, deixe todos os campos como estão.
Clique em Criar para criar a rede VPC.

Depois de clicar em Criar, a nova rede VPC vai aparecer na Redes VPC.

gcloud

Para criar uma rede VPC usando a ferramenta de linha de comando gcloud, digite o seguinte comando no terminal, em que NETWORK_NAME é o nome da rede VPC:

gcloud compute networks create NETWORK_NAME \
  --subnet-mode=auto

Depois de clicar em Criar, a nova rede VPC vai aparecer na página Redes VPC.

Para saber mais sobre como criar e gerenciar redes VPC, consulte Criar e gerenciar redes VPC.

Crie uma conexão privada

Console

Para criar uma conexão particular entre sua rede VPC e o serviço de produção, siga estas etapas:

Abra a página Redes VPC no console do Google Cloud.

Acessar redes VPC
Clique no nome da sua rede.

Você verá a página Detalhes da rede VPC.
Clique na guia Conexão de serviço particular.
1. Selecione a guia Intervalos de IP alocados para serviços.
2. Clique em Alocar intervalo de IP.
  
  Você vai encontrar a caixa pop-up Alocar um intervalo de IP interno.
  1. Digite um Nome para o intervalo de IP.
  2. Em Intervalo de IP, selecione Automático.
  3. No campo Comprimento do prefixo, digite o tamanho do prefixo para sua rede.
    
    Observação: o tamanho do prefixo precisa ser /24 ou menor, como /22, /21 etc.
  4. Clique em Alocar para alocar seu intervalo de IP.
    
    Observação: observe o intervalo de IP interno que é gerado para uso nas próximas etapas.
3. Selecione a guia Conexões particulares com os serviços.
4. Clique em Criar conexão.
  
  O pop-up Criar uma conexão particular vai aparecer.
  1. Em Alocação atribuída, selecione seu intervalo de IP.
  2. Clique em Conectar.
  Agora você verá sua conexão na tabela abaixo do Guia Conexões privadas com os Serviços.
  
  Clique em Ativar (Exportar rota personalizada) para garantir que as rotas do são aplicadas à rede em que o pool privado instâncias estão em execução.

Sua rede está configurada.

gcloud

Para criar uma conexão particular entre sua rede VPC e o serviço de produção, siga estas etapas:

Insira o seguinte comando no terminal para alocar um intervalo de IPs para seu serviço:
```
    gcloud compute addresses create RESERVED_RANGE_NAME \
      --global \
      --prefix-length=PREFIX_LENGTH \
      --network=VPC_NETWORK \
      --project=PROJECT_ID
```
Em que:
- RESERVED_RANGE_NAME é o nome do intervalo alocado. Por exemplo, my-allocated-range.
- PREFIX_LENGTH é o tamanho do prefixo da rede. O comprimento do prefixo precisa ser /24 ou menor, como /22, /21 etc.
- VPC_NETWORK é o nome da sua rede VPC, como my-vpc-network.
- PROJECT_ID é o ID do projeto que contém sua rede VPC.
Digite o seguinte comando no seu terminal para criar uma conexão particular:
```
    gcloud services vpc-peerings connect \
      --service=servicenetworking.googleapis.com \
      --ranges=RESERVED_RANGE_NAME \
      --network=VPC_NETWORK \
      --project=PROJECT_ID
```
Em que:
- RESERVED_RANGE_NAME é o nome do intervalo alocado que você criou na etapa anterior.
- VPC_NETWORK é o nome da rede VPC, como my-vpc-network.
- PROJECT_ID é o ID do projeto que contém sua rede VPC.
Digite o seguinte comando no seu terminal para garantir que as rotas da VPC sejam aplicadas à rede em que as instâncias do pool privado estão em execução:
```
    gcloud compute networks peerings update servicenetworking-googleapis-com \
      --export-custom-routes \
      --network=VPC_NETWORK \
      --project=PROJECT_ID
```
Em que:
- VPC_NETWORK é o nome da sua rede VPC, como my-vpc-network.
- PROJECT_ID é o ID do projeto que contém sua rede VPC.

Você configurou sua rede.

Para saber mais sobre como configurar uma rede, consulte Como configurar uma conexão particular entre sua rede VPC e a rede do produtor de serviços.

Criar um pool particular

Console

Para criar um pool privado usando o console do Google Cloud, conclua as seguintes etapas:

Abra a página Pool de workers no console do Google Cloud:

Abrir a página do pool de workers do Cloud Build
Selecione o projeto em que você quer criar o pool privado.
Na página Pool de worker, clique em Criar.

O painel Criar pool particular vai aparecer.
No painel lateral Criar pool privado, insira as seguintes informações:
1. Digite um Nome para o pool privado.
2. Selecione uma Região no menu suspenso.
3. Em Rede, insira as seguintes informações:
- Projeto: digite o ID ou número do projeto.
- Rede: insira o nome da sua rede VPC.
1. (Opcional) Desmarque a caixa Atribuir IPs externos para a configuração de rede mais restrita.

Você criou um pool particular.

gcloud

Para criar um pool privado usando a ferramenta de linha de comando gcloud, digite o seguinte comando no terminal:

      gcloud builds worker-pools create PRIVATEPOOL_ID \
        --project=PRIVATEPOOL_PROJECT_ID \
        --region=REGION \
        --peered-network=PEERED_NETWORK \
        --no-public-egress

Em que:

PRIVATEPOOL_ID é o identificador exclusivo do seu pool privado.
PRIVATEPOOL_PROJECT_ID é o ID do projeto do Google Cloud. em que você quer criar o pool privado.
REGION é uma das regiões com suporte.
PEERED_NETWORK é o URL do recurso de rede
--no-public-egress: se essa sinalização for definida, o pool privado será criado sem um endereço IP externo.

Você criou um pool particular.

Para saber mais sobre como criar e gerenciar pools particulares, consulte Como criar e gerenciar pools particulares.

Acessar recursos externos em uma rede privada

Por padrão, os endereços IP externos associados a pools privados do Cloud Build não são estáticos nem configuráveis. Eles são atribuídos pelo Google Cloud. Se você quiser configurar os pools particulares para acessar recursos externos da sua rede particular com um IP externo estático, configure uma máquina virtual (VM) no projeto para atuar como um gateway NAT autogerenciado para solicitações de proxy para a Internet pública. Depois disso, você precisa configurar rotas para encaminhar essas solicitações à VM e garantir que as rotas sejam trocadas com o projeto de rede de serviços.

Nesta seção, descrevemos como configurar seus pools privados para acessar por um IP externo estático seguindo estas etapas:

Criar um script de inicialização para configurar a VM para proxy de qualquer tráfego roteado da VM e disfarçar esse tráfego como originário do seu endereço IP:

#! /bin/bash
set -e

sysctl -w net.ipv4.ip_forward=1
IFACE=$(ip -brief link | tail -1 | awk  {'print $1'})
iptables -t nat -A POSTROUTING -o "$IFACE" -j MASQUERADE

Configure uma VM na mesma VPC do seu pool particular com uma regra para permitir que as solicitações sejam encapsuladas pela VPC:
```
gcloud compute instances create VM_NAME \
  --image-project=ubuntu-os-cloud --image-family=ubuntu-2204-lts \
  --network=NETWORK_NAME \
  --private-network-ip=INTERNAL_IP --can-ip-forward \
  --zone=ZONE \
  --subnet=SUBNETWORK \
  --tags=NAT_TAG  \
  --metadata-from-file=startup-script=STARTUP_SCRIPT
```
Em que:
- VM_NAME é o nome que você quer fornecer para a VM.
- NETWORK_NAME é o nome da rede que você criou na seção anterior.
- INTERNAL_IP é qualquer endereço IP interno válido dentro do intervalo da sub-rede da região da VM. Por exemplo, 10.128.0.2.
- ZONE é a zona associada à sua rede, como us-central1-a.
- Opcional: SUBNETWORK é o nome da sub-rede. O da sub-rede pode ser encontrado no REST equivalente para sua sub-rede neste formato: projects/project-id/regions/region/subnetworks/subnetwork-name. Se você selecionou Automático em Modo de conexão de sub-rede ao criar uma rede VPC, não é necessário especificar esse campo.
- NAT_TAG é o nome da tag do gateway NAT. que permite rotear solicitações condicionalmente, eles têm uma tag desta VM. É possível especificar qualquer nome para a tag.
- STARTUP_SCRIPT é o nome do script de inicialização criado na etapa anterior. Por exemplo, startup-script-example.sh. Neste exemplo, a sinalização --metadata-from-file é usada para transmitir o conteúdo do script de inicialização especificado para uma chamado startup-script.
Depois de executar esse comando, você verá uma saída que contém as valor do IP externo. Anote o valor do IP externo. Todo o tráfego do pool particular para o recurso externo passa por esse endereço. Você pode optar por usar esse endereço para mais configurações, como como configurar regras de firewall na rede externa.
Configure uma rota para direcionar todas as solicitações ao recurso externo para a instância criada na etapa anterior, permitindo que as solicitações sejam encaminhadas para as instâncias do pool particular:
```
gcloud compute routes create PRIVATE_POOL_ROUTE_NAME \  
  --destination-range=DESTINATION_RANGE \
  --next-hop-address=INTERNAL_IP \
  --network=NETWORK_NAME \
  --priority=POOL_ROUTE_PRIORITY
```
Em que:
- PRIVATE_POOL_ROUTE_NAME é o nome que você quer dar à rota.
- DESTINATION_RANGE é um intervalo de endereços CIDR válido que contém o destino para o qual você quer rotear. Por exemplo, uma instância do GitHub Enterprise Edition. Por exemplo, 8.8.8.0/24.
- INTERNAL_IP é o valor de IP interno obtido na etapa anterior. Por exemplo, 10.128.0.2.
- NETWORK_NAME é o nome da rede que você criou na seção anterior.
- POOL_ROUTE_PRIORITY é o número de prioridade que você quer especificar para a rota.
Observação: se você quiser direcionar todo o tráfego para a Internet (0.0.0.0/0) do pool particular para a VM do gateway NAT, é necessário especificar quatro regras de roteamento diferentes. Para imitar o espaço de endereço 0.0.0.0/0, é necessário definir um intervalo para 0.0.0.0/1 e 128.0.0.0/1.

Esse comando garante que qualquer tráfego de um build dentro de uma instância de pool privado seja roteado para o de proxy criada, e não roteada diretamente para a Internet pública.
Configure uma rota para encaminhar solicitações do proxy das instâncias marcadas para o intervalo de IP de destino externo. O comando a seguir cria uma rota para encaminhar solicitações para a Internet pública associada às suas instâncias de pool privado.
```
gcloud compute routes create NAT_EGRESS_ROUTE_NAME \ 
  --destination-range=DESTINATION_RANGE \    
  --next-hop-gateway=default-internet-gateway \
  --network=NETWORK_NAME \
  --priority=NAT_ROUTE_PRIORITY \
  --tags=NAT_TAG
```
Em que:
- NAT_EGRESS_ROUTE_NAME é o nome que você quer dar ao do gateway de NAT.
- DESTINATION_RANGE é o endereço do destino para o qual você quer encaminhar. Por exemplo, uma instância do GitHub Enterprise Edition. Por exemplo, 8.8.8.0/24.
- NETWORK_NAME é o nome da rede que você criou na seção anterior.
- NAT_TAG é o nome da tag do gateway NAT. que permite rotear solicitações condicionalmente, eles têm uma tag desta VM. É possível especificar qualquer nome para a tag.
- NAT_ROUTE_PRIORITY é o número da prioridade que você quer especificar para o trajeto.
  
  Observação: o valor especificado para NAT_ROUTE_PRIORITY precisa ser menor que o valor especificado para POOL_ROUTE_PRIORITY. Um valor menor significa uma prioridade mais alta.
Esse comando garante que qualquer tráfego da VM do proxy possa ser direcionado para a Internet pública.
Adicione uma regra de firewall para permitir o tráfego do pool particular na VM de gateway NAT:
```
gcloud compute firewall-rules create RULE_NAME \
  --direction=INGRESS --priority=FIREWALL_PRIORITY --action=ALLOW --rules=all \
  --network=NETWORK_NAME \
  --source-ranges=RESERVED_RANGE \
  --target-tags=NAT_TAG
```
Em que:
- RULE_NAME é o nome que você quer dar à regra de firewall.
- FIREWALL_PRIORITY é o número da prioridade que você quer especificar para a regra de firewall.
- NETWORK_NAME é o nome da rede que você criou na seção anterior.
- RESERVED_RANGE é o intervalo CIDR que você alocou ao configurar sua rede VPC.
- NAT_TAG é o nome da tag do gateway NAT que permite rotear solicitações condicionalmente, com base na presença ou ausência de uma tag dessa VM. É possível especificar qualquer nome para a tag.

Agora é possível acessar recursos externos do endereço IP estático da gateway NAT autogerenciado na sua VPC.

A seguir

Saiba mais sobre pools particulares.
Saiba como configurar o ambiente para criar pools particulares.
Saiba como acessar recursos em um JFrog Artifactory particular com pools particulares.