Exemplo: conectividade particular para uma instância do MySQL

Nesta página, explicamos por um exemplo como usar o Private Service Connect (PSC) para estabelecer uma conexão entre seu sistema de back-end do MySQL, que está em uma rede privada, e o ambiente de execução dos Integration Connectors.

Considerações

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

O anexo de serviço do PSC e o balanceador de carga precisam estar em sub-redes diferentes na mesma VPC. Especificamente, o anexo de serviço precisa estar em uma sub-rede NAT.
O software em execução nas VMs de back-end precisa responder às sondagens de tráfego com balanceamento de carga e de verificação de integridade enviadas ao endereço IP de cada regra de encaminhamento. O software precisa detectar em 0.0.0.0:<port> e não em um endereço IP específico atribuído a uma interface de rede. Para saber mais, consulte Verificação de integridade.
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 seu sistema de back-end.
- A sondagem de verificação de integridade precisa acessar o sistema de back-end. 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 ao servidor de back-end.
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 o sistema de back-end aceita 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 seu back-end. 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, seu back-end deve 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.

Exemplo

Suponha que você tenha uma instância do MySQL hospedada no Google Cloud em uma rede VPC privada e queira expor essa instância do MySQL ao ambiente de execução dos Integration Connectors.

A ilustração a seguir mostra como será o projeto de exemplo do Google Cloud após a configuração do anexo de serviço do PSC.

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 para o 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 neste tutorial, substitua BACKEND_SERVER_PORT por 3306, que é a porta padrão em que o servidor MySQL é 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_NAME --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.
Crie uma instância de VM.

Para criar uma instância de VM na VPC recém-criada, execute o seguinte comando:
```
gcloud compute instances create \
--image-family debian-10 \
--image-project debian-cloud \
--network-interface=network-tier=PREMIUM,subnet=SUBNET_NAME_2,no-address \
mysql-test
```
Esse comando cria uma instância de VM com o nome mysql-test.

Observação:para cumprir as práticas recomendadas de segurança, a opção --no-address cria a instância sem um endereço IP externo. No entanto, se a instância precisar acessar os repositórios de pacotes públicos durante a instalação do MySQL, permita o acesso à Internet configurando o Cloud NAT para gerenciar a conversão de endereços de rede.

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

SSH para sua instância de VM.

Crie uma regra de firewall para permitir o SSH.

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

SSH para sua instância de VM.

gcloud compute ssh \
    --tunnel-through-iap \
    mysql-test

Instale o servidor MySQL. Para instruções detalhadas, consulte Instalar o MySQL.

Conectar-se à instância do MySQL e criar dados de amostra.

Conecte-se ao MySQL usando o cliente do MySQL.
```
sudo mysql -u root -p
```
Crie um novo usuário e conceda acesso para se conectar de qualquer endereço de host.
```
CREATE USER 'test-user'@'%' IDENTIFIED BY 'test-pass';
GRANT ALL PRIVILEGES ON * . * TO 'test-user'@'%';
FLUSH PRIVILEGES;
```
Esse comando cria um usuário com o nome de usuário test-user e a senha test-pass.

Criar um banco de dados com os dados de amostra.

CREATE DATABASE test-db;
USE test-db;
CREATE TABLE Singers (SingerId int, FirstName varchar(255), LastName varchar(255));
INSERT INTO Singers (SingerId, FirstName, LastName) VALUES (1, 'Marc', 'Richards');

Saia do cliente MySQL.
```
mysql> exit
```
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 a instância de VM criada na etapa 2.
```
gcloud compute instance-groups unmanaged add-instances INSTANCE_GROUP_NAME --instances=mysql-test
```

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 3306, que é a porta padrão em que o servidor MySQL é executado.

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

gcloud compute firewall-rules create VPC_NETWORK-allow-health-check --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 VPC_NETWORK-allow-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 VPC_NETWORK-allow-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.
Verifique a configuração do PSC. É possível verificar a conectividade do anexo de serviço PSC criando uma conexão MySQL com o banco de dados test-db criado para este tutorial. Para etapas detalhadas sobre como criar uma conexão MySQL, consulte Criar uma conexão MySQL. Ao criar a conexão, na seção Destinations (consulte a etapa 5 em Criar uma conexão MySQL), selecione Destination type como Hostname e insira o endereço IP ou nome do host do endpoint apropriado. 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.

Anexo de serviço PSC para outros sistemas de back-end

Siga as etapas do exemplo anterior para configurar um anexo de serviço PSC para outros sistemas de back-end. No entanto, você vai precisar modificar as etapas 5 e 6 para incluir o sistema de back-end desejado. Depois de instalar o sistema de back-end na instância de VM, adicione-o ao grupo de instâncias e siga as etapas restantes.