Acesso à rede externa e conectividade privada em Microsoft Azure¶

Este tópico fornece detalhes de configuração para definir a conectividade privada de saída para um serviço externo por meio de acesso à rede externa. As principais diferenças entre as configurações de conectividade pública de saída e conectividade privada de saída são que, com a conectividade privada, você deve executar as seguintes operações:

Crie um ponto de extremidade de conectividade privada. Esta etapa requer a função ACCOUNTADMIN.
Crie a regra de rede para usar a propriedade PRIVATE_HOST_PORT. Esta propriedade inclui o URL Azure e o número da porta, o que permite que a conexão do Snowflake ao Microsoft Azure passe pela rede interna Microsoft Azure, evitando a Internet pública.

Custos de conectividade privada de saída¶

Você paga por cada ponto de extremidade de conectividade privada, juntamente com o total de dados processados. Para ver o preço desses itens, consulte a Tabela de consumo do serviço Snowflake.

Você pode explorar o custo desses itens filtrando os seguintes tipos de serviço ao consultar as exibições de faturamento nos esquemas ACCOUNT_USAGE e ORGANIZATION_USAGE:

OUTBOUND_PRIVATELINK_ENDPOINT
OUTBOUND_PRIVATELINK_DATA_PROCESSED

Por exemplo, você pode consultar a exibição USAGE_IN_CURRENCY_DAILY e filtrar por esses tipos de serviço.

Configuração de acesso à rede externa¶

Essas etapas são exclusivas para usar conectividade privada de saída com acesso de rede externa em Microsoft Azure:

Chame a função do sistema SYSTEM$PROVISION_PRIVATELINK_ENDPOINT para provisionar um ponto de extremidade de conectividade privada em Snowflake VNet para permitir que o Snowflake se conecte a um serviço externo usando conectividade privada:
```
USE ROLE ACCOUNTADMIN;

SELECT SYSTEM$PROVISION_PRIVATELINK_ENDPOINT(
  '/subscriptions/1111-22-333-4444-55555/resourceGroups/external-access/providers/Microsoft.Sql/servers/externalaccessdemo',
  'externalaccessdemo.database.windows.net',
  'sqlServer'
);
```
No Portal do Azure e como proprietário do recurso do Azure API Management, aprove o ponto de extremidade privado. Para obter mais informações, consulte a documentação do Microsoft Azure.

Crie um banco de dados e esquemas para armazenar a regra de rede, o segredo e o procedimento:

CREATE DATABASE ext_network_access_db;
CREATE SCHEMA secrets;
CREATE SCHEMA network_rules;
CREATE SCHEMA procedures;

Crie uma regra de rede, especificando a propriedade PRIVATE_HOST_PORT para habilitar a conectividade privada:

CREATE OR REPLACE NETWORK RULE ext_network_access_db.network_rules.azure_sql_private_rule
   MODE = EGRESS
   TYPE = PRIVATE_HOST_PORT
   VALUE_LIST = ('externalaccessdemo.database.windows.net');

Crie um segredo para armazenar com segurança as credenciais de acesso:

CREATE OR REPLACE SECRET ext_network_access_db.secrets.secret_password
   TYPE = PASSWORD
   USERNAME = 'my-username'
   PASSWORD = 'my-password';

Crie uma integração de acesso externo, especificando a regra de rede da etapa anterior:

CREATE OR REPLACE EXTERNAL ACCESS INTEGRATION azure_private_access_sql_store_integration
   ALLOWED_NETWORK_RULES = (ext_network_access_db.network_rules.azure_sql_private_rule)
   ALLOWED_AUTHENTICATION_SECRETS = (ext_network_access_db.secrets.secret_password)
   ENABLED = TRUE;

Crie um procedimento para conectar ao serviço externo:

CREATE OR REPLACE PROCEDURE ext_network_access_db.procedures.connect_azure_sqlserver()
  RETURNS TABLE()
  LANGUAGE PYTHON
  RUNTIME_VERSION = 3.10
  HANDLER = 'connect_sqlserver'
  EXTERNAL_ACCESS_INTEGRATIONS = (azure_private_access_sql_store_integration)
  SECRETS = ('cred' = ext_network_access_db.secrets.secret_password)
  IMPORTS = ('@demo/pytds.zip')
  PACKAGES = ('snowflake-snowpark-python','pyopenssl','bitarray','certifi')
AS $$
import pytds
import certifi
import _snowflake
from snowflake.snowpark import types as T

def connect_sqlserver(session):
   server = 'externalaccessdemo.database.windows.net'
   database = 'externalaccess'
   username_password_object = _snowflake.get_username_password('cred');


   # Create a connection to the database
   with pytds.connect(server, database, username_password_object.username, username_password_object.password, cafile=certifi.where(), validate_host=False) as conn:
         with conn.cursor() as cur:
            cur.execute("""
            SELECT O.OrderId,
                  O.OrderDate,
                  O.SodName,
                  O.UnitPrice,
                  O.Quantity,
                  C.Region
            FROM Orders AS O
            INNER JOIN Customers AS C
               ON O.CustomerID = C.CustomerID;""")
            rows = cur.fetchall()

            schema = T.StructType([
                  T.StructField("ORDER_ID", T.LongType(), True),
                  T.StructField("ORDER_DATE", T.DateType(), True),
                  T.StructField("SOD_NAME", T.StringType(), True),
                  T.StructField("UNIT_PRICE", T.FloatType(), True),
                  T.StructField("QUANTITY", T.FloatType(), True),
                  T.StructField("REGION", T.StringType(), True)
               ])

            final_df = session.createDataFrame(rows, schema)

            return final_df
   $$;

Chame o procedimento para conectar ao serviço externo:
```
CALL ext_network_access_db.procedures.connect_azure_sqlserver();
```

Repita essas etapas para cada configuração de acesso à rede externa que exija conectividade privada.

Se você não precisar mais do ponto de extremidade de conectividade privada para a integração de acesso à rede externa, chame a função do sistema SYSTEM$DEPROVISION_PRIVATELINK_ENDPOINT.