Gerenciar e conectar-se com clusters do Amazon Aurora DSQL usando o AWS PrivateLink

Com o AWS PrivateLink para Amazon Aurora DSQL, é possível provisionar endpoints da Amazon VPC de interface (endpoints de interface) em sua Amazon Virtual Private Cloud. Esses endpoints podem ser acessados diretamente por meio da Amazon VPC e do Direct Connect pelas aplicações que estão no ambiente on-premises ou por emparelhamento da Amazon VPC pelas aplicações que estão em uma Região da AWS diferente. Usando endpoints de interface e o AWS PrivateLink, é possível simplificar a conectividade de rede privada das aplicações com o Aurora DSQL.

As aplicações dentro da Amazon VPC podem acessar o Aurora DSQL usando endpoints de interface da Amazon VPC sem exigir endereços IP públicos.

Os endpoints de interface são representados por uma ou mais interfaces de rede elástica (ENIs) que recebem endereços IP privados de sub-redes na Amazon VPC. As solicitações ao Aurora DSQL por meio de endpoints de interface permanecem na AWS. Para ter mais informações sobre como conectar a Amazon VPC à rede on-premises, consulte o Guia do usuário do Direct Connect e o Guia do usuário do AWS Site-to-Site VPN.

Para ter mais informações sobre como criar endpoints de interface, consulte Access an AWS service using an interface Amazon VPC endpoint no Guia do usuário do AWS PrivateLink.

Tipos de endpoint da Amazon VPC para o Aurora DSQL

O Aurora DSQL exige dois tipos diferentes de endpoint do AWS PrivateLink.

Considerações ao usar o AWS PrivateLink para o Aurora DSQL

As considerações sobre a Amazon VPC se aplicam ao AWS PrivateLink para o Aurora DSQL. Para acessar mais informações, consulte Acessar um serviço da AWS usando um endpoint da VPC de interface e Cotas do AWS PrivateLink no “Guia do AWS PrivateLink”.

Gerenciar clusters do Aurora DSQL usando o AWS PrivateLink

Você pode usar a AWS Command Line Interface ou os kits de desenvolvimento de software (SDKs) da AWS para gerenciar clusters do Aurora DSQL por meio de endpoints de interface do Aurora DSQL.

Criar um Amazon VPC endpoint

Para criar um endpoint de interface da Amazon VPC, consulte Create an Amazon VPC endpoint no “Guia do AWS PrivateLink”.

aws ec2 create-vpc-endpoint \
--region region \
--service-name com.amazonaws.region.dsql \
--vpc-id your-vpc-id \
--subnet-ids your-subnet-id \
--vpc-endpoint-type Interface \
--security-group-ids client-sg-id \

Para usar o nome de DNS regional padrão para solicitações de API do Aurora DSQL, não desabilite o DNS privado ao criar o endpoint de interface do Aurora DSQL. Quando o DNS privado estiver habilitado, as solicitações ao serviço Aurora DSQL dentro da Amazon VPC serão automaticamente resolvidas para o endereço IP privado do endpoint da Amazon VPC, em vez do nome de DNS público. Quando o DNS privado estiver habilitado, as solicitações do Aurora DSQL feitas na Amazon VPC serão automaticamente resolvidas para seu endpoint da Amazon VPC.

Se o DNS privado não estiver habilitado, use os parâmetros --region e --endpoint-url com comandos da AWS CLI para gerenciar clusters do Aurora DSQL por meio dos endpoints de interface do Aurora DSQL.

Listar clusters usando um URL de endpoint

No exemplo a seguir, substitua a Região da AWS us-east-1 e o nome de DNS do ID vpce-1a2b3c4d-5e6f.dsql.us-east-1.vpce.amazonaws.com do endpoint da VPC por suas próprias informações.

aws dsql --region us-east-1 --endpoint-url https://vpce-1a2b3c4d-5e6f.dsql.us-east-1.vpce.amazonaws.com list-clusters

Operações de API

Consulte a Referência de API do Aurora DSQL para ver a documentação sobre gerenciamento de recursos no Aurora DSQL.

Gerenciar políticas de endpoint

Ao testar e configurar minuciosamente as políticas de endpoint da Amazon VPC, você pode ajudar a garantir que o cluster do Aurora DSQL seja seguro, compatível e alinhado com os requisitos específicos de controle de acesso e governança da sua organização.

Exemplo: política de acesso completo ao Aurora DSQL

A política a seguir concede acesso completo a todas as ações e recursos do Aurora DSQL por meio do endpoint especificado da Amazon VPC.

aws ec2 modify-vpc-endpoint \
    --vpc-endpoint-id vpce-xxxxxxxxxxxxxxxxx \
    --region region \
    --policy-document '{
      "Version": "2012-10-17",		 	 	 
      "Statement": [
        {
          "Effect": "Allow",
          "Principal": "*",
          "Action": "dsql:*",
          "Resource": "*"
        }
      ]
    }'  

Exemplo: política de acesso restrito ao Aurora DSQL

A política a seguir só permite estas ações do Aurora DSQL.

Todas as outras ações do Aurora DSQL são negadas.

JSON

{
  "Version":"2012-10-17",		 	 	 
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": "*",
      "Action": [
        "dsql:CreateCluster",
        "dsql:GetCluster",
        "dsql:ListClusters"
      ],
      "Resource": "*"
    }
  ]
} 

Conectar-se com clusters do Aurora DSQL usando o AWS PrivateLink

Depois que o endpoint do AWS PrivateLink estiver configurado e ativo, você poderá se conectar ao cluster do Aurora DSQL usando um cliente PostgreSQL. As instruções de conexão abaixo descrevem as etapas para criar o nome de host adequado para conexão por meio do endpoint do AWS PrivateLink.

Configurar um endpoint de conexão do AWS PrivateLink

Etapa 1: obter o nome do serviço para o cluster

Ao criar um endpoint do AWS PrivateLink para se conectar ao cluster, primeiro é necessário buscar o nome do serviço específico do cluster.

AWS CLI

aws dsql get-vpc-endpoint-service-name \
--region us-east-1 \
--identifier your-cluster-id        

Exemplo de resposta

{
    "serviceName": "com.amazonaws.us-east-1.dsql-fnh4"
}

O nome do serviço inclui um identificador, como dsql-fnh4 no exemplo. Esse identificador também é necessário ao criar o nome do host para se conectar ao cluster.

AWS SDK for Python (Boto3)

import boto3

dsql_client = boto3.client('dsql', region_name='us-east-1')
response = dsql_client.get_vpc_endpoint_service_name(
    identifier='your-cluster-id'
)
service_name = response['serviceName']
print(f"Service Name: {service_name}")                                      

AWS SDK for Java 2.x

import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.dsql.DsqlClient;
import software.amazon.awssdk.services.dsql.model.GetVpcEndpointServiceNameRequest;
import software.amazon.awssdk.services.dsql.model.GetVpcEndpointServiceNameResponse;

String region = "us-east-1";
String clusterId = "your-cluster-id";

DsqlClient dsqlClient = DsqlClient.builder()
    .region(Region.of(region))
    .credentialsProvider(DefaultCredentialsProvider.create())
    .build();

GetVpcEndpointServiceNameResponse response = dsqlClient.getVpcEndpointServiceName(
    GetVpcEndpointServiceNameRequest.builder()
        .identifier(clusterId)
        .build()
);
String serviceName = response.serviceName();
System.out.println("Service Name: " + serviceName);                 

Etapa 2: criar o endpoint da Amazon VPC

Usando o nome do serviço obtido na etapa anterior, crie um endpoint da Amazon VPC.

AWS CLI

aws ec2 create-vpc-endpoint \
    --region us-east-1 \
    --service-name service-name-for-your-cluster \
    --vpc-id your-vpc-id \
    --subnet-ids subnet-id-1 subnet-id-2  \
    --vpc-endpoint-type Interface \
    --security-group-ids security-group-id

Exemplo de resposta

{
    "VpcEndpoint": {
        "VpcEndpointId": "vpce-0123456789abcdef0",
        "VpcEndpointType": "Interface",
        "VpcId": "vpc-0123456789abcdef0",
        "ServiceName": "com.amazonaws.us-east-1.dsql-fnh4",
        "State": "pending",
        "RouteTableIds": [],
        "SubnetIds": [
            "subnet-0123456789abcdef0",
            "subnet-0123456789abcdef1"
        ],
        "Groups": [
            {
                "GroupId": "sg-0123456789abcdef0",
                "GroupName": "default"
            }
        ],
        "PrivateDnsEnabled": true,
        "RequesterManaged": false,
        "NetworkInterfaceIds": [
            "eni-0123456789abcdef0",
            "eni-0123456789abcdef1"
        ],
        "DnsEntries": [
            {
                "DnsName": "*.dsql-fnh4.us-east-1.vpce.amazonaws.com",
                "HostedZoneId": "Z7HUB22UULQXV"
            }
        ],
        "CreationTimestamp": "2025-01-01T00:00:00.000Z"
    }
} 

SDK for Python

import boto3

ec2_client = boto3.client('ec2', region_name='us-east-1')
response = ec2_client.create_vpc_endpoint(
    VpcEndpointType='Interface',
    VpcId='your-vpc-id',
    ServiceName='com.amazonaws.us-east-1.dsql-fnh4',  # Use the service name from previous step
    SubnetIds=[
        'subnet-id-1',
        'subnet-id-2'
    ],
    SecurityGroupIds=[
        'security-group-id'
    ]
)

vpc_endpoint_id = response['VpcEndpoint']['VpcEndpointId']
print(f"VPC Endpoint created with ID: {vpc_endpoint_id}")               

SDK for Java 2.x

Use um URL de endpoint para as APIs do Aurora DSQL

import software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.ec2.Ec2Client;
import software.amazon.awssdk.services.ec2.model.CreateVpcEndpointRequest;
import software.amazon.awssdk.services.ec2.model.CreateVpcEndpointResponse;
import software.amazon.awssdk.services.ec2.model.VpcEndpointType;

String region = "us-east-1";
String serviceName = "com.amazonaws.us-east-1.dsql-fnh4";  // Use the service name from previous step
String vpcId = "your-vpc-id";

Ec2Client ec2Client = Ec2Client.builder()
    .region(Region.of(region))
    .credentialsProvider(DefaultCredentialsProvider.create())
    .build();

CreateVpcEndpointRequest request = CreateVpcEndpointRequest.builder()
    .vpcId(vpcId)
    .serviceName(serviceName)
    .vpcEndpointType(VpcEndpointType.INTERFACE)
    .subnetIds("subnet-id-1", "subnet-id-2")
    .securityGroupIds("security-group-id")
    .build();

CreateVpcEndpointResponse response = ec2Client.createVpcEndpoint(request);
String vpcEndpointId = response.vpcEndpoint().vpcEndpointId();
System.out.println("VPC Endpoint created with ID: " + vpcEndpointId);            

Configuração adicional ao se conectar via Direct Connect ou emparelhamento da Amazon VPC

Pode ser necessária alguma configuração adicional para conectar-se aos clusters do Aurora DSQL usando um endpoint de conexão do AWS PrivateLink de dispositivos on-premises via emparelhamento da Amazon VPC ou Direct Connect. Essa configuração só não será necessária se a sua aplicação estiver em execução na mesma Amazon VPC que o endpoint do AWS PrivateLink. As entradas de DNS privadas criadas acima não serão resolvidas corretamente fora da Amazon VPC do endpoint, mas você pode criar seus próprios registros de DNS privados que serão resolvidos no endpoint de conexão do AWS PrivateLink.

Crie um registro DNS CNAME privado que aponte para o nome de domínio totalmente qualificado do endpoint do AWS PrivateLink. O nome de domínio do registro de DNS criado deve ser construído por meio dos seguintes componentes:

Crie o registro DNS CNAME com um nome de domínio no seguinte formato: *.service-identifier.region.on.aws

O formato do nome de domínio é importante por dois motivos:

Se não for possível criar registros DNS privados, você ainda poderá se conectar ao Aurora DSQL. Consulte Conectar-se a um cluster do Aurora DSQL usando um endpoint do AWS PrivateLink sem DNS privado.

Conectar-se a um cluster do Aurora DSQL usando um endpoint de conexão do AWS PrivateLink

Depois que o endpoint do AWS PrivateLink estiver configurado e ativo (verifique se State está available), você pode se conectar ao cluster do Aurora DSQL usando um cliente PostgreSQL. Para ter instruções sobre como usar os SDKs da AWS, siga os guias em Programming with Aurora DSQL. Você deve alterar o endpoint do cluster para que corresponda ao formato do nome do host.

Criar o nome do host

O nome do host para conexão por meio do AWS PrivateLink é diferente do nome do host de DNS público. Você precisa criá-lo usando os componentes a seguir.

Use o seguinte formato: .: cluster-id.service-identifier.region.on.aws

Exemplo: conectar-se usando o PostgreSQL

# Set environment variables
export CLUSTERID=your-cluster-id
export REGION=us-east-1
export SERVICE_IDENTIFIER=dsql-fnh4  # This should match the identifier in your service name

# Construct the hostname
export HOSTNAME="$CLUSTERID.$SERVICE_IDENTIFIER.$REGION.on.aws"

# Generate authentication token
export PGPASSWORD=$(aws dsql --region $REGION generate-db-connect-admin-auth-token --hostname $HOSTNAME)

# Connect using psql
psql -d postgres -h $HOSTNAME -U admin        

Conectar-se a um cluster do Aurora DSQL usando um endpoint do AWS PrivateLink sem DNS privado

As instruções de conexão acima dependem de registros DNS privados. Se sua aplicação estiver sendo executada na mesma Amazon VPC que seu endpoint do AWS PrivateLink, os registros DNS serão criados para você. Como alternativa, se você estiver se conectando a partir de dispositivos on-premises via emparelhamento da Amazon VPC ou Direct Connect, poderá criar seus próprios registros DNS privados. No entanto, a configuração do registro DNS nem sempre é possível devido às restrições de rede impostas por suas equipes de segurança. Se sua aplicação precisar se conectar usando o Direct Connect ou a partir de uma Amazon VPC emparelhada e a configuração do registro DNS não for possível, você ainda poderá se conectar ao Aurora DSQL.

O Aurora DSQL usa a parte do ID do cluster do seu nome de host para identificar o cluster de conexão, mas se a configuração do registro DNS não for possível, o Aurora DSQL aceita a especificação do cluster de destino usando a opção de conexão amzn-cluster-id. Com essa opção, é possível usar o nome de domínio totalmente qualificado do seu endpoint do AWS PrivateLink como seu nome de host ao se conectar.

Exemplo: especificar a opção de conexão do ID do cluster usando o PostgreSQL

# Set environment variables
export CLUSTERID=your-cluster-id
export REGION=us-east-1
export HOSTNAME=vpce-04037adb76c111221-d849uc2p.dsql-fnh4.us-east-1.vpce.amazonaws.com # This should match your endpoint's fully-qualified domain name

# Construct the hostname used to generate the authentication token
export AUTH_HOSTNAME="$CLUSTERID.dsql.$REGION.on.aws"

# Generate authentication token
export PGPASSWORD=$(aws dsql --region $REGION generate-db-connect-admin-auth-token --hostname $AUTH_HOSTNAME)

# Specify the amzn-cluster-id connection option
export PGOPTIONS="-c amzn-cluster-id=$CLUSTERID"

# Connect using psql
psql -d postgres -h $HOSTNAME -U admin        

Solução de problemas com o AWS PrivateLink

Problemas e soluções comuns

A tabela a seguir lista problemas e soluções comuns relacionados ao AWS PrivateLink com o Aurora DSQL.

Recursos relacionados

Para saber mais, consulte os seguintes recursos: