Externer Netzwerkzugang und private Konnektivität auf Microsoft Azure¶

In diesem Thema finden Sie Details zur Konfiguration der ausgehenden privaten Konnektivität zu einem externen Dienst durch einen externen Netzwerkzugang. Die Hauptunterschiede zwischen den Konfigurationen für ausgehende öffentliche Konnektivität und ausgehende private Konnektivität bestehen darin, dass Sie bei der privaten Konnektivität die folgenden Operationen durchführen müssen:

Erstellen Sie einen privaten Konnektivitätsendpunkt. Für diesen Schritt ist die ACCOUNTADMIN-Rolle erforderlich.
Erstellen Sie die Netzwerkregel, um die PRIVATE_HOST_PORT-Eigenschaft zu verwenden. Diese Eigenschaft beinhaltet die Azure-URL und die Portnummer, die es ermöglicht, dass die Verbindung von Snowflake zu Microsoft Azure über das Microsoft Azure-interne Netzwerk erfolgt und das öffentliche Internet vermieden wird.

Kosten für ausgehende private Konnektivität¶

Sie zahlen für jeden privaten Konnektivitätsendpunkt zusammen mit den insgesamt verarbeiteten Daten. Die Preise für diese Artikel finden Sie in der Snowflake Service Consumption Table.

Sie können die Kosten für diese Element ermitteln, indem Sie bei der Abfrage von Abrechnungsansichten in den Schemata ACCOUNT_USAGE und ORGANIZATION_USAGE nach den folgenden Diensttypen filtern:

OUTBOUND_PRIVATELINK_ENDPOINT
OUTBOUND_PRIVATELINK_DATA_PROCESSED

Sie können zum Beispiel die Ansicht USAGE_IN_CURRENCY_DAILY abfragen und nach folgenden Diensttypen filtern.

Konfigurieren Sie den externen Zugriff auf das Netzwerk¶

Diese Schritte gelten nur für die Verwendung ausgehender privater Konnektivität mit externem Netzwerkzugang auf Microsoft Azure:

Rufen Sie die SYSTEM$PROVISION_PRIVATELINK_ENDPOINT-Systemfunktion auf, um einen privaten Konnektivitätsendpunkt in Ihrer Snowflake VNet bereitzustellen, damit Snowflake eine Verbindung zu einem externen Dienst über private Konnektivität herstellen kann:
```
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'
);
```
Genehmigen Sie im Azure-Portal und als Eigentümer der Azure-API-Verwaltungsressource den privaten Endpunkt. Weitere Informationen finden Sie in der Microsoft Azure-Dokumentation.
Erstellen Sie eine Datenbank und Schemas, um die Netzwerkregel, das Geheimnis und die Prozedur zu speichern:
```
CREATE DATABASE ext_network_access_db;
CREATE SCHEMA secrets;
CREATE SCHEMA network_rules;
CREATE SCHEMA procedures;
```

Erstellen Sie eine Netzwerkregel und geben Sie die Eigenschaft PRIVATE_HOST_PORT an, um private Konnektivität zu ermöglichen:

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');

Erstellen Sie ein Geheimnis, um die Anmeldeinformationen sicher zu speichern:

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

Erstellen Sie eine Integration für externen Zugriff, wobei Sie die Netzwerkregel aus dem vorherigen Schritt angeben:

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;

Erstellen Sie eine Prozedur, um eine Verbindung mit dem externen Dienst herzustellen:

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

Rufen Sie die Prozedur auf, um eine Verbindung zum externen Dienst herzustellen:
```
CALL ext_network_access_db.procedures.connect_azure_sqlserver();
```

Wiederholen Sie diese Schritte für jede Konfiguration des externen Netzwerkzugangs, die eine private Konnektivität erfordert.

Wenn Sie den privaten Konnektivitätsendpunkt für die Integration des Zugriffs auf externe Netzwerke nicht mehr benötigen, rufen Sie die SYSTEM$DEPROVISION_PRIVATELINK_ENDPOINT-Systemfunktion auf.