Accès au réseau externe et connectivité privée sur Microsoft Azure¶

Cette rubrique fournit des détails de configuration pour configurer la connectivité privée sortante vers un service externe via l’accès au réseau externe. Les principales différences entre les configurations de connectivité publique sortante et de connectivité privée sortante sont que, avec la connectivité privée, vous devez effectuer les opérations suivantes :

Créez un point de terminaison de connectivité privé. Cette étape nécessite le rôle ACCOUNTADMIN.
Créez la règle de réseau pour utiliser la propriété PRIVATE_HOST_PORT. Cette propriété comprend l’URL Azure et le numéro de port, qui permet la connexion de Snowflake à Microsoft Azure pour passer par le réseau interne Microsoft Azure, évitant l’Internet public.

Coûts de la connectivité privée sortante¶

Vous payez pour le point de terminaison de la connectivité privée et pour toutes les données traitées. Pour connaître les prix de ces éléments, consultez le tableau de consommation des services de Snowflake.

Vous pouvez connaître le coût de ces éléments en filtrant sur les types de services suivants lors de la requête des vues de facturation dans les schémas ACCOUNT_USAGE et ORGANIZATION_USAGE :

OUTBOUND_PRIVATELINK_ENDPOINT
OUTBOUND_PRIVATELINK_DATA_PROCESSED

Par exemple, vous pouvez interroger la vue USAGE_IN_CURRENCY_DAILY et filtrer sur ces types de services.

Configurer l’accès au réseau externe¶

Ces étapes sont propres à l’utilisation de la connectivité privée sortante avec accès au réseau externe sur Microsoft Azure :

Appelez la fonction système SYSTEM$PROVISION_PRIVATELINK_ENDPOINT pour provisionner un point de terminaison de connectivité privé dans votre VNet Snowflake pour permettre à Snowflake de se connecter à un service externe à l’aide d’une connectivité privée :
```
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'
);
```
Dans le portail Azure et en tant que propriétaire de la ressource Azure API Management, approuvez le point de terminaison privé. Pour plus d’informations, voir la documentation Microsoft Azure.
Créez une base de données et des schémas pour stocker la règle, le secret et la procédure du réseau :
```
CREATE DATABASE ext_network_access_db;
CREATE SCHEMA secrets;
CREATE SCHEMA network_rules;
CREATE SCHEMA procedures;
```

Créez une règle de réseau, en spécifiant la propriété PRIVATE_HOST_PORT permettant une connectivité privée :

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

Créez un secret pour stocker en toute sécurité les identifiants de connexion d’accès :

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

Créez une intégration d’accès externe, en spécifiant la règle de réseau de l’étape précédente :

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;

Créez une procédure pour vous connecter au service externe :

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

Appelez la procédure pour vous connecter au service externe :
```
CALL ext_network_access_db.procedures.connect_azure_sqlserver();
```

Répétez ces étapes pour chaque configuration d’accès au réseau externe qui nécessite une connectivité privée.

Si vous n’avez plus besoin du point de terminaison de connectivité privée pour l’intégration de l’accès au réseau externe, appelez la fonction système SYSTEM$DEPROVISION_PRIVATELINK_ENDPOINT.