Acesso à rede externa e conectividade privada em AWS¶

Você pode configurar o Snowflake para conectividade privada de saída com um serviço externo do AWS por meio do acesso à rede externa.

Diferentemente da conectividade pública, com a conectividade privada você deve realizar 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 que a propriedade TYPE seja definida como PRIVATE_HOST_PORT.

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 da conectividade privada com um serviço externo do Amazon S3¶

Chame a função de sistema SYSTEM$PROVISION_PRIVATELINK_ENDPOINT para especificar que o Snowflake está se conectando a um serviço AWS S3 e o nome de host a ser usado ao se conectar ao serviço:
```
USE ROLE ACCOUNTADMIN;
SELECT SYSTEM$PROVISION_PRIVATELINK_ENDPOINT(
  'com.amazonaws.us-west-2.s3',
  '*.s3.us-west-2.amazonaws.com'
);
```
Nota

O asterisco em *.s3.us-west-2.amazonaws.com especifica que você pode usar o ponto de extremidade para acessar vários buckets do S3.
Execute a seguinte instrução SQL para criar uma regra de rede que permita que o Snowflake envie solicitações para um destino externo, certificando-se de definir a propriedade TYPE como PRIVATE_HOST_PORT:
```
CREATE OR REPLACE NETWORK RULE aws_s3_network_rule
  MODE = EGRESS
  TYPE = PRIVATE_HOST_PORT
  VALUE_LIST = ('external-access-iam-bucket.s3.us-west-2.amazonaws.com');
```

Execute a seguinte instrução SQL para criar uma integração de segurança para autenticação da API externa:

CREATE OR REPLACE SECURITY INTEGRATION aws_s3_security_integration
  TYPE = API_AUTHENTICATION
  AUTH_TYPE = AWS_IAM
  ENABLED = TRUE
  AWS_ROLE_ARN = 'arn:aws:iam::736112632310:role/external-access-iam-bucket';

Execute a seguinte instrução SQL para obter os valores STORAGE_AWS_IAM_USER_ARN e STORAGE_AWS_EXTERNAL_ID para o usuário IAM:
```
DESC SECURITY INTEGRATION aws_s3_security_integration;
```
Usando os valores de STORAGE_AWS_IAM_USER_ARN e STORAGE_AWS_EXTERNAL_ID, siga Etapa 5 em Option 1: Configure a Snowflake storage integration to access Amazon S3 para conceder ao usuário IAM acesso ao serviço Amazon S3.
Execute a seguinte instrução SQL para criar um token a ser usado para autenticação com o serviço AWS S3:
```
CREATE OR REPLACE SECRET aws_s3_access_token
  TYPE = CLOUD_PROVIDER_TOKEN
  API_AUTHENTICATION = aws_s3_security_integration;
```

Execute a seguinte instrução SQL para criar uma integração de acesso externo que use a regra de rede e o token criados nas etapas anteriores:

CREATE OR REPLACE EXTERNAL ACCESS INTEGRATION aws_s3_external_access_integration
  ALLOWED_NETWORK_RULES = (aws_s3_network_rule)
  ALLOWED_AUTHENTICATION_SECRETS = (aws_s3_access_token)
  ENABLED = TRUE
  COMMENT = 'Testing S3 connectivity';

Execute uma das seguintes instruções SQL para criar uma função que possa usar a integração de acesso externo e o token que foram criados anteriormente:

CREATE OR REPLACE FUNCTION aws_s3_python_function()
  RETURNS VARCHAR
  LANGUAGE PYTHON
  EXTERNAL_ACCESS_INTEGRATIONS = (aws_s3_external_access_integration)
  RUNTIME_VERSION = '3.12'
  SECRETS = ('cred' = aws_s3_access_token)
  PACKAGES = ('boto3')
  HANDLER = 'main_handler'
AS
$$
  import boto3
  import _snowflake
  from botocore.config import Config

  def main_handler():
      # Get the previously created token as an object
      cloud_provider_object = _snowflake.get_cloud_provider_token('cred')

      # Configure boto3 connection settings
      config = Config(
          retries=dict(total_max_attempts=9),
          connect_timeout=30,
          read_timeout=30,
          max_pool_connections=50
      )

      # Connect to S3 using boto3
      s3 = boto3.client(
          's3',
          region_name='us-west-2',
          aws_access_key_id=cloud_provider_object.access_key_id,
          aws_secret_access_key=cloud_provider_object.secret_access_key,
          aws_session_token=cloud_provider_object.token,
          config=config
      )

      # Use the s3 object upload/download resources
      # ...

      return 'Successfully connected to AWS S3'
$$;

CREATE OR REPLACE FUNCTION aws_s3_java_function()
  RETURNS STRING
  LANGUAGE JAVA
  EXTERNAL_ACCESS_INTEGRATIONS = (aws_s3_external_access_integration)
  SECRETS = ('cred' = aws_s3_access_token)
  HANDLER = 'AWSTokenProvider.handle'
AS
$$
  import com.snowflake.snowpark_java.types.CloudProviderToken;
  import com.snowflake.snowpark_java.types.SnowflakeSecrets;

  public class AWSTokenProvider {
      public static String handle() {
          // Get the previously created token as an object
          SnowflakeSecrets sfSecret = SnowflakeSecrets.newInstance();
          CloudProviderToken cloudProviderToken = sfSecret.getCloudProviderToken("cred");

          // Create variables for the AWS session credentials
          String accessKeyId = cloudProviderToken.getAccessKeyId();
          String secretAccessKey = cloudProviderToken.getSecretAccessKey();
          String token = cloudProviderToken.getToken();

          // Use the token to create an S3 client
          // ...

          return "Successfully connected to AWS S3 with the following access token: " + token;
      }
  }
$$;

Execute um dos seguintes comandos SQL para executar a função que você criou:
SELECT aws_s3_python_function();
SELECT aws_s3_java_function();

Configuração da conectividade privada com um serviço externo do Amazon Bedrock¶

Chame a função de sistema SYSTEM$PROVISION_PRIVATELINK_ENDPOINT para especificar que o Snowflake está se conectando aos serviços AWS S3 e Amazon Bedrock e os nomes de host a serem usados ao se conectar aos serviços:

USE ROLE ACCOUNTADMIN;
SELECT SYSTEM$PROVISION_PRIVATELINK_ENDPOINT(
  'com.amazonaws.us-west-2.s3',
  '*.s3.us-west-2.amazonaws.com'
);

SELECT SYSTEM$PROVISION_PRIVATELINK_ENDPOINT(
  'com.amazonaws.us-west-2.bedrock-runtime',
  'bedrock-runtime.us-west-2.amazonaws.com'
);

Execute a seguinte instrução SQL para criar uma regra de rede que permita que o Snowflake envie solicitações para um destino externo, certificando-se de definir a propriedade TYPE como PRIVATE_HOST_PORT:
```
CREATE OR REPLACE NETWORK RULE bedrock_network_rule
  MODE = EGRESS
  TYPE = PRIVATE_HOST_PORT
  VALUE_LIST = ('bedrock-runtime.us-west-2.amazonaws.com');
```

Execute a seguinte instrução SQL para criar uma integração de segurança para autenticação da API externa:

CREATE OR REPLACE SECURITY INTEGRATION bedrock_security_integration
  TYPE = API_AUTHENTICATION
  AUTH_TYPE = AWS_IAM
  ENABLED = TRUE
  AWS_ROLE_ARN = 'arn:aws:iam::736112632310:role/external-access-iam-bucket';

Execute a seguinte instrução SQL para obter os valores STORAGE_AWS_IAM_USER_ARN e STORAGE_AWS_EXTERNAL_ID para o usuário IAM:
```
DESC  SECURITY INTEGRATION bedrock_security_integration;
```
Usando os valores de STORAGE_AWS_IAM_USER_ARN e STORAGE_AWS_EXTERNAL_ID, siga Etapa 5 em Option 1: Configure a Snowflake storage integration to access Amazon S3 para conceder ao usuário IAM acesso ao serviço Amazon Bedrock.
Execute a seguinte instrução SQL para criar um token a ser usado para autenticação com o serviço AWS Bedrock:
```
CREATE OR REPLACE SECRET aws_bedrock_access_token
  TYPE = CLOUD_PROVIDER_TOKEN
  API_AUTHENTICATION = bedrock_security_integration;
```

Execute a seguinte instrução SQL para criar uma integração de acesso externo que use a regra de rede e o token criados nas etapas anteriores:

CREATE OR REPLACE EXTERNAL ACCESS INTEGRATION bedrock_external_access_integration
  ALLOWED_NETWORK_RULES = (bedrock_network_rule)
  ALLOWED_AUTHENTICATION_SECRETS=(aws_bedrock_access_token)
  ENABLED=true ;

Execute a seguinte instrução SQL para criar uma função que possa usar a integração de acesso externo e o token que foram criados anteriormente:

CREATE OR REPLACE FUNCTION bedrock_private_connectivity_tests(
  id INT,
  instructions VARCHAR,
  user_context VARCHAR,
  model_id VARCHAR
)
  RETURNS VARCHAR
  LANGUAGE PYTHON
  EXTERNAL_ACCESS_INTEGRATIONS = (bedrock_external_access_integration)
  RUNTIME_VERSION = '3.8'
  SECRETS = ('cred' = aws_bedrock_access_token)
  PACKAGES = ('boto3')
  HANDLER = 'bedrock_py'
AS
$$
  import boto3
  import json
  import _snowflake
  def bedrock_py(id, instructions, user_context, model_id):
      # Get the previously created token as an object
      cloud_provider_object = _snowflake.get_cloud_provider_token('cred')
      cloud_provider_dictionary = {
          "ACCESS_KEY_ID": cloud_provider_object.access_key_id,
          "SECRET_ACCESS_KEY": cloud_provider_object.secret_access_key,
          "TOKEN": cloud_provider_object.token
      }
      # Assign AWS credentials and choose a region
      boto3_session_args = {
          'aws_access_key_id': cloud_provider_dictionary["ACCESS_KEY_ID"],
          'aws_secret_access_key': cloud_provider_dictionary["SECRET_ACCESS_KEY"],
          'aws_session_token': cloud_provider_dictionary["TOKEN"],
          'region_name': 'us-west-2'
      }
      session = boto3.Session(**boto3_session_args)
      client = session.client('bedrock-runtime')
      # Prepare the request body for the specified model
      def prepare_request_body(model_id, instructions, user_context):
          default_max_tokens = 512
          default_temperature = 0.7
          default_top_p = 1.0
          if model_id == 'amazon.titan-text-express-v1':
              body = {
                  "inputText": f"<SYSTEM>Follow these:{instructions}<END_SYSTEM>\n<USER_CONTEXT>Use this user context in your response:{user_context}<END_USER_CONTEXT>",
                  "textGenerationConfig": {
                      "maxTokenCount": default_max_tokens,
                      "stopSequences": [],
                      "temperature": default_temperature,
                      "topP": default_top_p
                  }
              }
          elif model_id == 'ai21.j2-ultra-v1':
              body = {
                  "prompt": f"<SYSTEM>Follow these:{instructions}<END_SYSTEM>\n<USER_CONTEXT>Use this user context in your response:{user_context}<END_USER_CONTEXT>",
                  "temperature": default_temperature,
                  "topP": default_top_p,
                  "maxTokens": default_max_tokens
              }
          elif model_id == 'anthropic.claude-3-sonnet-20240229-v1:0':
              body = {
                  "max_tokens": default_max_tokens,
                  "messages": [{"role": "user", "content": f"<SYSTEM>Follow these:{instructions}<END_SYSTEM>\n<USER_CONTEXT>Use this user context in your response:{user_context}<END_USER_CONTEXT>"}],
                  "anthropic_version": "bedrock-2023-05-31"
              }
          else:
              raise ValueError("Unsupported model ID")
          return json.dumps(body)
      # Call Bedrock to get a completion
      body = prepare_request_body(model_id, instructions, user_context)
      response = client.invoke_model(modelId=model_id, body=body)
      response_body = json.loads(response.get('body').read())
      # Parse the API response based on the model
      def get_completion_from_response(response_body, model_id):
          if model_id == 'amazon.titan-text-express-v1':
              output_text = response_body.get('results')[0].get('outputText')
          elif model_id == 'ai21.j2-ultra-v1':
              output_text = response_body.get('completions')[0].get('data').get('text')
          elif model_id == 'anthropic.claude-3-sonnet-20240229-v1:0':
              output_text = response_body.get('content')[0].get('text')
          else:
              raise ValueError("Unsupported model ID")
          return output_text
      # Get the generated text from Bedrock
      output_text = get_completion_from_response(response_body, model_id)
      return output_text
  $$;

Execute a seguinte instrução SQL para executar a função que você criou:

SELECT bedrock_private_connectivity_tests(1, 'Summarize the main benefits of attending this university.', 'University of Waterloo', 'amazon.titan-text-express-v1');