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.

Faturamento e preços

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.

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:

  1. 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'
);
    Copy

  2. 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.

  3. 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;
    Copy

  4. 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');
    Copy

  5. 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';
    Copy

  6. 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;
    Copy

  7. 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
   $$;
    Copy

  8. Chame o procedimento para conectar ao serviço externo:

    CALL ext_network_access_db.procedures.connect_azure_sqlserver();
    Copy

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.

Linguagem: Português