Authentifizieren von Verbindungen¶

Verwenden Sie Single Sign-On (SSO) über einen Webbrowser¶

Wenn Sie Snowflake für die Verwendung von Single Sign-On (SSO) konfiguriert haben, können Sie Ihre Clientanwendung so konfigurieren, dass browserbasiertes SSO für die Authentifizierung verwendet wird.

In Ihrem Anwendungscode:

1. Setzen Sie die Option authenticator auf EXTERNALBROWSER.

2. Rufen Sie zum Herstellen einer Verbindung die Methode connectAsync und nicht die Methode connect auf.

Beispiel:

// Use a browser to authenticate via SSO.
var connection = snowflake.createConnection({
  ...,
  authenticator: "EXTERNALBROWSER"
});
// Establish a connection. Use connectAsync, rather than connect.
connection.connectAsync(
  function (err, conn)
  {
    ... // Handle any errors.
  }
).then(() =>
{
  // Execute SQL statements.
  var statement = connection.execute({...});
});

Weitere Informationen zur Verwendung von browserbasiertem SSO für die Authentifizierung finden Sie unter Browser-basiertes SSO.

Verwenden Sie native SSO über Okta.¶

Wenn Sie Snowflake für die Verwendung von Single Sign-On (SSO) konfiguriert haben, und zwar über Okta, können Sie Ihre Clientanwendung so konfigurieren, dass sie die native SSO-Authentifizierung über Okta verwendet.

In Ihrem Anwendungscode:

1. Legen Sie die folgenden Optionen fest:

   • Setzen Sie die Option authenticator auf den Okta-URL-Endpunkt für Ihr Okta-Konto (z. B. https://<Name_des_Okta-Kontos>.okta.com).

   • Setzen Sie die Optionen username und password auf den Benutzernamen und das Kennwort für Ihren Identitätsanbieter (IdP).

2. Rufen Sie zum Herstellen einer Verbindung die Methode connectAsync und nicht die Methode connect auf.

Beispiel:

// Use native SSO authentication through Okta.
var connection = snowflake.createConnection({
  ...,
  username: '<user_name_for_okta>',
  password: '<password_for_okta>',
  authenticator: "https://myaccount.okta.com"
});

// Establish a connection.
connection.connectAsync(
  function (err, conn)
  {
    ... // Handle any errors.
  }
);

// Execute SQL statements.
var statement = connection.execute({...});

Weitere Informationen zur Verwendung der nativen SSO-Authentifizierung über Okta finden Sie unter Natives SSO – Nur Okta.

Verwenden Sie Authentifizierung von Schlüsselpaaren und Schlüsselpaar-Rotation¶

Der Treiber unterstützt Schlüsselpaar-Authentifizierung und Schlüsselrotation. Führen Sie die folgenden Schritte aus, um die Schlüsselpaar-Authentifizierung und die Schlüsselrotation zu verwenden:

1. Konfigurieren Sie die Schlüsselpaar-Authentifizierung, wie unter Schlüsselpaar-Authentifizierung und Schlüsselpaar-Rotation erläutert.

2. In Ihrem Anwendungscode:

   1. Setzen Sie die Option authenticator auf SNOWFLAKE_JWT.

   2. Verwenden Sie den privaten Schlüssel zur Authentifizierung auf eine der folgenden Arten:

      • Setzen Sie die Option privateKey auf den privaten Schlüssel.

      • Setzen Sie die Option privateKeyPath auf den Pfad zur Datei des privaten Schlüssels.

        Wenn die Datei verschlüsselt ist, müssen Sie auch die Option privateKeyPass auf die Passphrase setzen, um den privaten Schlüssel zu entschlüsseln.

Im folgenden Beispiel wird der private Schlüssel aus einer Datei geladen und die Option privateKey auf den privaten Schlüssel gesetzt:

// Read the private key file from the filesystem.
var crypto = require('crypto');
var fs = require('fs');
var privateKeyFile = fs.readFileSync('<path_to_private_key_file>/rsa_key.p8');

// Get the private key from the file as an object.
const privateKeyObject = crypto.createPrivateKey({
  key: privateKeyFile,
  format: 'pem',
  passphrase: 'passphrase'
});

// Extract the private key from the object as a PEM-encoded string.
var privateKey = privateKeyObject.export({
  format: 'pem',
  type: 'pkcs8'
});

// Use the private key for authentication.
var connection = snowflake.createConnection({
  ...
  authenticator: "SNOWFLAKE_JWT",
  privateKey: privateKey
});

// Establish a connection.
connection.connect(
  function (err, conn)
  {
    ... // Handle any errors.
  }
);

// Execute SQL statements.
var statement = connection.execute({...});

Copy

Im folgenden Beispiel wird die Option privateKeyPath auf eine verschlüsselte Datei mit privatem Schlüssel gesetzt und die Option privateKeyPass auf die Passphrase gesetzt, die zum Entschlüsseln des privaten Schlüssels verwendet wird:

// Use an encrypted private key file for authentication.
// Specify the passphrase for decrypting the key.
var connection = snowflake.createConnection({
  ...
  authenticator: "SNOWFLAKE_JWT",
  privateKeyPath: "<path-to-privatekey>/privatekey.p8",
  privateKeyPass: '<passphrase_to_decrypt_the_private_key>'
});

// Establish a connection.
connection.connect(
  function (err, conn)
  {
    ... // Handle any errors.
  }
);

// Execute SQL statements.
var statement = connection.execute({...});

Copy

Verwenden von OAuth¶

Um eine Verbindung mit OAuth herzustellen, setzen Sie die Option authenticator auf OAUTH und die Option token auf das OAuth-Zugriffstoken. Beispiel:

// Use OAuth for authentication.
var connection = snowflake.createConnection({
  ...
  authenticator: "OAUTH",
  token: "<your_oauth_token>"
});

// Establish a connection.
connection.connect(
  function (err, conn)
  {
    ... // Handle any errors.
  }
);

// Execute SQL statements.
var statement = connection.execute({...});

Weitere Informationen dazu finden Sie unter Clients, Treiber und Konnektoren.

Verwenden Sie eine MFA Kennung¶

Sie können eine Verbindung zu Snowflake herstellen, indem Sie eine mehrstufige Authentifizierung (MFA) als Kennung angeben, anstatt auf eine externe Bestätigung zu warten, z. B. eine Push-Benachrichtigung von Duo. Der Treiber bietet die folgenden Möglichkeiten, eine Kennung für MFA anzugeben:

• Setzen Sie die Option passcodeInPassword auf true und fügen Sie das Kennwort als Teil der Zeichenfolge ein, ähnlich wie im Folgenden:

  const connection = snowflake.createConnection({
      account: process.env.SNOWFLAKE_TEST_ACCOUNT,
      username: process.env.SNOWFLAKE_TEST_USER,
      ...
      authenticator: 'USERNAME_PASSWORD_MFA',
      password: "abc123987654", // passcode 987654 is part of the password
      passcodeInPassword: true  // because passcodeInPassword is true
  });
  

  Copy

• Setzen Sie die Option passcode auf den Wert des Kennworts, um das Kennwort und die Kennung getrennt anzugeben, ähnlich wie im Folgenden:

  const connection = snowflake.createConnection({
      account: process.env.SNOWFLAKE_TEST_ACCOUNT,
      username: process.env.SNOWFLAKE_TEST_USER,
      ...
      authenticator: 'USERNAME_PASSWORD_MFA',
      password: "abc123", // password and MFA passcode are input separately
      passcode: "987654"
  });
  

  Copy

  Um diesen Ansatz zu verwenden, stellen Sie sicher, dass die Option passcodeInPassword auf false (der Standardwert) eingestellt ist.

Weitere Informationen zu diesen Optionen finden Sie unter passcode.

Cache für Authentifizierung mit Token¶

Der Snowflake Node.js-Treiber bietet die Möglichkeit, die Token SSO und MFA zu cachen.

ALTER ACCOUNT SET ALLOW_ID_TOKEN = TRUE;

const connection = snowflake.createConnection({
  account: process.env.SNOWFLAKE_TEST_ACCOUNT,
  username: process.env.SNOWFLAKE_TEST_USER,
  database: process.env.SNOWFLAKE_TEST_DATABASE,
  schema: process.env.SNOWFLAKE_TEST_SCHEMA,
  warehouse: process.env.SNOWFLAKE_TEST_WAREHOUSE,
  authenticator: 'EXTERNALBROWSER',
  clientStoreTemporaryCredential: true,
});

ALTER ACCOUNT SET ALLOW_CLIENT_MFA_CACHING = TRUE;

const connection = snowflake.createConnection({
  account: process.env.SNOWFLAKE_TEST_ACCOUNT,
  username: process.env.SNOWFLAKE_TEST_USER,
  database: process.env.SNOWFLAKE_TEST_DATABASE,
  schema: process.env.SNOWFLAKE_TEST_SCHEMA,
  warehouse: process.env.SNOWFLAKE_TEST_WAREHOUSE,
  authenticator: 'USERNAME_PASSWORD_MFA',
  clientRequestMFAToken: true,
});

const sampleCustomManager = {
  read: function (key) {
  //(do something with the key)
    return token;
  },
  write: function (key, token) {
  //(do something with the key and token)
  },
  remove: function (key) {
    //(do something with the key)
  }
};

const myCredentialManager = require('<your custom credential manager module>')
const snowflake = require('snowflake-sdk');

snowflake.configure({
  customCredentialManager: myCredentialManager
})

const connection = snowflake.createConnection({
  account: process.env.SNOWFLAKE_TEST_ACCOUNT,
  database: process.env.SNOWFLAKE_TEST_DATABASE,
  schema: process.env.SNOWFLAKE_TEST_SCHEMA,
  warehouse: process.env.SNOWFLAKE_TEST_WAREHOUSE,
  authenticator: 'USERNAME_PASSWORD_MFA',
  clientRequestMFAToken: true,
});