Exemplo: conectividade particular para uma instância do Cloud SQL

Nesta página, explicamos como usar o Private Service Connect (PSC) para estabelecer uma conexão entre sua instância do Cloud SQL ativada para Private Service Access (PSA) e o ambiente de execução dos Integration Connectors. A instância do Cloud SQL pode ser de qualquer um dos seguintes tipos:

Considerações

Ao criar um anexo de serviço PSC, considere os seguintes pontos-chave:

O anexo de serviço PSC e o balanceador de carga são criados em sub-redes diferentes na mesma VPC. Especificamente, o anexo de serviço é sempre criado em uma sub-rede NAT.
Os servidores proxy SOCKS5 precisam estar vinculados ao endereço IP 0.0.0.0:<port> porque isso é necessário para o tráfego de entrada do balanceador de carga e das sondagens de verificação de integridade. Para saber mais, consulte Verificação de integridade.
O tráfego do balanceador de carga e da sondagem de verificação de integridade precisa ser enviado para a mesma porta.
Configurar as regras de firewall para facilitar o fluxo de tráfego.
Regras de entrada
- O tráfego da sub-rede do anexo de serviço do PSC deve chegar à sub-rede do ILB.
- Dentro da sub-rede do ILB, ele poderá enviar tráfego para os servidores proxy SOCKS5.
- A sondagem de verificação de integridade precisa acessar os servidores proxy SOCKS5. As sondagens de verificação de integridade do Google Cloud têm um intervalo de IP fixo (35.191.0.0/16, 130.211.0.0/22). Portanto, esses IPs podem ter permissão para enviar tráfego para os servidores proxy SOCKS.
Regras de saída

O tráfego de saída é ativado por padrão em um projeto do Google Cloud, a menos que regras de negação específicas estejam configuradas.
Todos os componentes do Google Cloud, como o anexo de serviço PSC e o balanceador de carga, precisam estar na mesma região.
Seu sistema de back-end não deve estar aberto à rede pública, porque isso pode ser um problema de segurança. No entanto, verifique se os servidores proxy SOCKS5 aceitam tráfego nos seguintes cenários:
- Balanceadores de carga de passagem (ILB L4 TCP/UDP): as solicitações dos IPs NAT do anexo de serviço PSC precisam ser capazes de alcançar seus servidores proxy SOCKS5. Esses IPs NAT são gerados automaticamente. Portanto, é preciso permitir todo o intervalo de IP da sub-rede NAT em que o anexo de serviço reside. Para mais informações, consulte Sub-redes do Private Service Connect.
- Balanceadores de carga baseados em proxy/HTTP(s) (ILB de proxy L4, ILB L7): todas as novas solicitações são originadas do balanceador de carga. Portanto, seus servidores proxy SOCKS5 precisam aceitar solicitações da sub-rede de proxy da sua rede VPC. Para mais informações, consulte Sub-redes somente proxy para balanceadores de carga baseados no Envoy.

Configurar o PSC para uma instância do Cloud SQL

Os Integration Connectors usam o proxy de autenticação do Cloud SQL para se conectar a uma instância do Cloud SQL. O proxy do Cloud SQL Auth é compatível com encadeamento por meio de um proxy SOCKS5, que permite encaminhar tráfego criptografado do proxy do Cloud SQL Auth para a instância de destino do Cloud SQL. Portanto, você precisa de servidores proxy SOCKS5 para se conectar a uma instância privada do Cloud SQL.

O diagrama a seguir mostra como será o projeto do Google Cloud depois que o anexo de serviço do PSC for configurado para um exemplo de configuração de instância do Cloud SQL.

Neste exemplo, os servidores proxy SOCKS5 são expostos por meio de um anexo de serviço para que o PSC possa se conectar com segurança a uma instância do Cloud SQL. Os servidores proxy SOCKS têm acesso a uma instância do Cloud SQL por meio do Acesso a serviços particulares. Os servidores proxy SOCKS5 estão em um grupo de instâncias do Compute Engine não gerenciadas, e é possível decidir o número de instâncias de proxy com base no tráfego de entrada esperado.

Como o tráfego flui no exemplo?

Os Integration Connectors enviam uma solicitação para um anexo de serviço.
O anexo de serviço encaminha a solicitação para um ILB L4.
O ILB L4 envia uma solicitação aos servidores proxy SOCKS5.
O ILB tem as regras de encaminhamento e realiza o encaminhamento de portas. Por padrão, um proxy SOCKS5 detecta na porta 1080. No entanto, se os servidores proxy SOCKS5 detectarem em uma porta diferente, será necessário abrir essa porta para escutar no ILB.
Os servidores proxy SOCKS5 encaminham a solicitação para a instância do Cloud SQL.

Antes de começar

Antes de criar um anexo de serviço do PSC para o cenário de amostra, faça o seguinte:

Instale a CLI gcloud.
Ative a API Compute Engine e a API Service Networking no seu projeto do Google Cloud.
Para tornar os comandos da CLI menos detalhados, defina os valores de PROJECT_ID, REGION e ZONE usando os seguintes comandos:
```
gcloud config set project PROJECT_ID
gcloud config set compute/region REGION
gcloud config set compute/zone ZONE
```
Para os comandos deste tutorial, substitua BACKEND_SERVER_PORT por 1080, que é a porta padrão em que um servidor proxy SOCKS5 é executado.
É recomendável criar uma nova rede VPC e usá-la ao testar este cenário de amostra. Depois de testar o cenário, é possível excluir a rede VPC e outros recursos.
Deve haver pelo menos uma conexão existente que você tenha criado. A conexão pode ser de qualquer tipo. Ter uma conexão atual permite buscar o ID do projeto do diretório de serviços no ambiente de execução do Integration Connectors. Esse ID do projeto é necessário para criar o anexo de serviço PSC.

Criar um anexo de serviço PSC

Para criar um anexo de serviço PSC para o cenário de exemplo, faça o seguinte:

Crie uma rede VPC e as sub-redes necessárias.
1. Criar uma rede VPC.
```
gcloud compute networks create VPC_NETWORK \
--project=PROJECT_ID --subnet-mode=custom --mtu=1460 \
--bgp-routing-mode=regional
```
2. Adicione a sub-rede 1.
```
gcloud compute networks subnets create SUBNET_NAME_1 \
--network=VPC_NETWORK --range=SUBNET_RANGE_1 \
--purpose=PRIVATE_SERVICE_CONNECT
```
  Esse comando cria Subnet-1 como uma sub-rede NAT que será usada exclusivamente para hospedar o anexo de serviço PSC. Não é possível hospedar nenhum outro serviço nessa sub-rede NAT.
3. Adicione a sub-rede 2.
```
gcloud compute networks subnets create SUBNET_NAME_2 \
--network=VPC_NETWORK --range=SUBNET_RANGE_2
```
Observação : o anexo de serviço PSC não pode existir na mesma sub-rede que o balanceador de carga. Portanto, você precisa de duas sub-redes.
Criar uma instância privada do Cloud SQL.
1. Configure o acesso a serviços particulares.
  1. Aloque um intervalo de endereços IP.
```
gcloud compute addresses create google-managed-services-VPC_NETWORK \
--global --purpose=VPC_PEERING --prefix-length=16 \
--network=projects/PROJECT_ID/global/networks/VPC_NETWORK
```
  2. Crie uma conexão particular.
```
gcloud services vpc-peerings connect \
--service=servicenetworking.googleapis.com \
--ranges=google-managed-services-VPC_NETWORK \
--network=VPC_NETWORK \
--project=PROJECT_ID
```
2. Crie uma instância do Cloud SQL com um IP privado.
```
gcloud beta sql instances create \
INSTANCE_NAME \
--database-version=DATABASE_VERSION \
--cpu=NUMBER_OF_CPUs \
--memory=MEMORY \
--zone=ZONE \
--root-password=ROOT_PASSWORD \
--network=projects/PROJECT_ID/global/networks/VPC_NETWORK \
--no-assign-ip \
--allocated-ip-range-name=google-managed-services-VPC_NETWORK
```
  Especifique o DATABASE_VERSION com base no tipo de instância que você quer criar. É possível criar uma instância do tipo MySQL, PostgreSQL ou SQL Server. Para ver a lista de todas as versões compatíveis do banco de dados, consulte Versão do banco de dados SQL.
  
  Esse comando cria um usuário padrão para a instância do Cloud SQL. Veja a seguir os usuários padrão que serão criados para as várias instâncias do Cloud SQL *:
  - Cloud SQL para MySQL: root
  - Cloud SQL para SQL Server: sqlserver
  - Cloud SQL para PostgreSQL: postgres
3. (Opcional) Se não quiser usar o usuário padrão, crie um novo usuário para a instância do Cloud SQL recém-criada.
```
gcloud sql users create USER --host=% --instance=INSTANCE_NAME \
--password=PASSWORD
```
  Verifique se o usuário tem todas as permissões necessárias para acessar o banco de dados que você criará na próxima etapa.
4. Criar um banco de dados na instância recém-criada do Cloud SQL.
```
gcloud sql databases create DATABASE_NAME \
--instance=INSTANCE_NAME
```

Configure o Cloud NAT.

Criar um roteador simples.

gcloud compute routers create NAT_ROUTER_NAME \
    --network=VPC_NETWORK

Configure a conversão de endereços de rede.

gcloud compute routers nats create NAT_GATEWAY_NAME \
    --router=NAT_ROUTER_NAME \
    --auto-allocate-nat-external-ips \
    --nat-all-subnet-ip-ranges

Crie instâncias de VM do Compute Engine para executar servidores proxy SOCKS5.
1. Crie a instância do proxy 1.
```
gcloud compute instances create PROXY_INSTANCE_1 \
--project=PROJECT_ID \
--network-interface=network-tier=PREMIUM,subnet=SUBNET_NAME_2,no-address
```
Com base nas suas necessidades, é possível criar quantas instâncias de VM forem necessárias.

Crie uma regra de firewall que permita o SSH nas instâncias de VM.

gcloud compute firewall-rules create FIREWALL_RULE_NAME_SSH \
--direction=INGRESS --priority=1000 --network=VPC_NETWORK --allow=tcp:22

Instale o proxy SOCKS5.

As etapas detalhadas para instalar e configurar um servidor proxy SOCKS5 estão fora do escopo deste documento, e é possível instalar qualquer proxy SOCKS5 de sua escolha. As etapas a seguir mostram como instalar e configurar o servidor proxy Dante SOCKS5.

SSH para sua instância de VM.

gcloud compute ssh \
    --tunnel-through-iap \
    PROXY_INSTANCE_1

Instale o servidor proxy Dante SOCKS5.

sudo apt update
sudo apt install dante-server

Verifique a interface do servidor.
```
sudo ip a
```

Crie o backup da configuração do Dante.

sudo mv /etc/danted.conf /etc/danted.conf.bak

Crie um novo arquivo de configuração do Dante.
```
sudo nano /etc/danted.conf
```

Copie a seguinte configuração no arquivo de configuração:

logoutput: /var/log/socks.log
# Bind the server to the 0.0.0.0 IP address to allow traffic
# traffic from the load balancer and the health check probes.
internal: 0.0.0.0 port = 1080
external: ens4
clientmethod: none
socksmethod: none
user.privileged: root
user.notprivileged: nobody
client pass {
        from: 0.0.0.0/0 to: 0.0.0.0/0
        log: error connect disconnect
}
client block {
        from: 0.0.0.0/0 to: 0.0.0.0/0
        log: connect error
}
socks pass {
        from: 0.0.0.0/0 to: 0.0.0.0/0
        log: error connect disconnect
}
socks block {
        from: 0.0.0.0/0 to: 0.0.0.0/0
        log: connect error
}

Reinicie o servidor Dante e verifique o status.

sudo systemctl restart danted
sudo systemctl status danted

Saia da instância de VM.
```
exit
```

Configure um grupo de instâncias não gerenciadas.
1. Crie um grupo de instâncias não gerenciadas.
```
gcloud compute instance-groups unmanaged create INSTANCE_GROUP_NAME
```
  Observação: este tutorial usa um grupo de instâncias não gerenciadas. É possível criar um grupo de instâncias gerenciadas para maior confiabilidade.
2. Adicione ao grupo as instâncias de VM criadas na etapa 3.
```
gcloud compute instance-groups unmanaged add-instances INSTANCE_GROUP_NAME \
--instances=PROXY_INSTANCE_1
```

Crie uma sondagem de verificação de integridade e permita o tráfego dela.

Crie a sondagem de verificação de integridade.
```
gcloud compute health-checks create tcp HEALTH_CHECK_NAME \
--port BACKEND_SERVER_PORT --region=REGION
```
Nesse comando, defina BACKEND_SERVER_PORT como 1080, que é a porta padrão em que os servidores proxy SOCKS5 são executados.

Crie uma regra de firewall para permitir o tráfego da sondagem.

gcloud compute firewall-rules create FIREWALL_RULE_NAME_HEALTHCHECK \
--direction=INGRESS --priority=1000 --network=VPC_NETWORK --allow=tcp:BACKEND_SERVER_PORT \
--source-ranges=35.191.0.0/16,130.211.0.0/22

Crie um balanceador de carga interno L4 e permita o tráfego do balanceador de carga.

Crie um serviço de back-end.

gcloud compute backend-services create BACKEND_SERVICE \
--load-balancing-scheme=internal --protocol=tcp --health-checks=HEALTH_CHECK_NAME \
--health-checks-region=REGION

Adicione o grupo de instâncias ao serviço de back-end.

gcloud compute backend-services add-backend BACKEND_SERVICE \
--instance-group=INSTANCE_GROUP_NAME \
--instance-group-zone=ZONE

Crie uma regra de encaminhamento.

gcloud compute forwarding-rules create FORWARDING_RULE_NAME \
--load-balancing-scheme=internal --network=VPC_NETWORK --subnet=SUBNET_NAME_2 \
--ip-protocol=TCP --ports=BACKEND_SERVER_PORT --backend-service=BACKEND_SERVICE \
--backend-service-region=REGION

Crie uma regra de firewall que permita o tráfego interno do balanceador de carga para o grupo de instâncias.

gcloud compute firewall-rules create FIREWALL_RULE_NAME_INTERNAL \
--direction=INGRESS --priority=1000 --network=VPC_NETWORK \
--action=ALLOW --rules=all --source-ranges=SUBNET_RANGE_2

Crie o anexo de serviço do PSC.
1. Crie uma regra de firewall para permitir o tráfego do anexo de serviço PSC para o balanceador de carga interno criado na etapa anterior.
```
gcloud compute firewall-rules create FIREWALL_RULE_NAME_SA \
--direction=INGRESS --priority=1000 --network=VPC_NETWORK \
--allow=tcp:BACKEND_SERVER_PORT --source-ranges=SUBNET_RANGE_1
```
2. Crie o anexo de serviço com aprovação explícita.
```
gcloud compute service-attachments create SERVICE_ATTACHMENT_NAME \
--producer-forwarding-rule=FORWARDING_RULE_NAME  \
--connection-preference=ACCEPT_MANUAL \
--consumer-accept-list=SERVICE_DIRECTORY_PROJECT_ID=LIMIT \
--nat-subnets=SUBNET_NAME_1
```
  Nesse comando, LIMIT é o limite de conexão para o projeto. O limite de conexões é o número de endpoints do Private Service Connect do consumidor que podem se conectar a esse serviço. Para entender como conseguir o SERVICE_DIRECTORY_PROJECT_ID, consulte Receber o ID do projeto do diretório de serviço.
Crie um anexo de endpoint.
Pense no anexo de endpoint como uma interface para o anexo de serviço PSC. Não é possível usar o anexo de serviço PSC diretamente para configurar a conectividade particular. O anexo de serviço PSC só pode ser acessado por meio de um anexo de endpoint. E é possível criar o anexo de endpoint como um endereço IP ou nome do host. Depois de criar o anexo de endpoint, use-o ao configurar um conector para conectividade particular. Para mais informações, consulte Criar um anexo de endpoint.

Observação: use o endereço IP ou o nome do host do anexo de endpoint como o endereço do proxy SOCKS5 ao criar a conexão.
Verifique a configuração do PSC.
É possível verificar a conectividade particular criando uma conexão do Cloud SQL e configurando o servidor proxy SOCKS5, conforme mostrado neste tutorial. Para ver as etapas detalhadas de como criar uma conexão, consulte a documentação específica do conector do Cloud SQL para MySQL, Cloud SQL para PostgreSQL ou Cloud SQL para SQL Server. Ao criar a conexão, na seção Destinations (na etapa 5), selecione Destination type como Host address e, em seguida, insira o endereço IP ou o nome do host do anexo de endpoint para os detalhes do servidor proxy SOCKS5. Defina o valor da porta como 1080, a menos que você tenha configurado uma porta diferente para o servidor proxy SOCKS5. Se a conexão for criada com sucesso, o status da conexão recém-criada será Active na página "Conexões" no Console do Cloud.

Consiga o ID do projeto do diretório de serviços

Uma prática recomendada é criar o anexo de serviço PSC para que ele aceite solicitações apenas de projetos do Google Cloud especificados. No entanto, para fazer isso, você precisa do ID do projeto do diretório de serviços associado ao seu projeto do Google Cloud. Para conseguir o ID do projeto do diretório de serviços, use a API List Connections, conforme mostrado no exemplo a seguir.

Sintaxe

curl -X GET \
    -H "authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json" \
    "https://connectors.googleapis.com/v1/projects/CONNECTORS_PROJECT_ID/locations/-/connections"

Substitua:

CONNECTORS_PROJECT_ID: o ID do projeto do Google Cloud em que você criou a conexão.

Exemplo

Este exemplo usa o ID do projeto do diretório de serviços do projeto connectors-test do Google Cloud.

curl -X GET \
    -H "authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json" \
    "https://connectors.googleapis.com/v1/projects/connectors-test/locations/-/connections"

A execução deste comando no terminal exibe uma resposta semelhante a esta:

.....
{
  "connections": [
    {
      "name": "projects/connectors-test/locations/asia-northeast1/connections/big-query-iam-invalid-sa",
      "createTime": "2022-10-07T09:02:31.905048520Z",
      "updateTime": "2022-10-07T09:22:39.993778690Z",
      "connectorVersion": "projects/connectors-test/locations/global/providers/gcp/connectors/bigquery/versions/1",
      "status": {
        "state": "ACTIVE"
      },
      "configVariables": [
        {
          "key": "project_id",
          "stringValue": "connectors-test"
        },
        {
          "key": "dataset_id",
          "stringValue": "testDataset"
        }
      ],
      "authConfig": {},
      "serviceAccount": "564332356444-compute@developer.gserviceaccount.com",
      "serviceDirectory": "projects/abcdefghijk-tp/locations/asia-northeast1/namespaces/connectors/services/runtime",
      "nodeConfig": {
        "minNodeCount": 2,
        "maxNodeCount": 50
      }
    },
....

No exemplo de saída, para o projeto connectors-test do Google Cloud, o ID do projeto do diretório de serviços é abcdefghijk-tp.