Verwenden von programmatische Zugriffstoken für die Authentifizierung¶
Sie können ein programmatisches Zugriffstoken verwenden, um sich bei den folgenden Snowflake-Endpunkten zu authentifizieren:
Bemerkung
Die Verwendung von programmatischen Zugriffstoken zur Authentifizierung bei Snowpark Container Services-Endpunkten wird noch nicht unterstützt.
Sie können auch ein programmatisches Zugriffstoken als Ersatz für ein Kennwort verwenden:
Anwendungen von Drittanbietern, die eine Verbindung zu Snowflake herstellen (z. B. Tableau und PowerBI).
Snowflake-APIs und -Bibliotheken (wie die Snowpark-API und die Snowflake Python-API).
Snowflake-Befehlszeilen-Clients (wie die Snowflake-CLI und SnowSQL.
Sie können programmatische Zugriffstoken sowohl für menschliche Benutzer (Benutzer mit TYPE=PERSON) als auch für Dienstbenutzer (Benutzer mit TYPE=SERVICE) erstellen.
Voraussetzungen¶
Sie müssen die folgenden Voraussetzungen erfüllen, um programmatische Zugriffstoken zu erstellen und zu verwenden:
Anforderungen der Netzwerkrichtlinie¶
Standardmäßig muss der Benutzer einer Netzwerkrichtlinie mit einer oder mehreren Netzwerkregeln unterliegen, um programmatische Zugriffstoken zu erzeugen oder zu verwenden:
Für Dienstbenutzer (wobei TYPE=SERVICE für den Benutzer) können Sie nur dann ein Token erzeugen oder verwenden, wenn der Benutzer einer Netzwerkrichtlinie unterliegt.
Diese Voraussetzung schränkt die Verwendung des Tokens auf Anfragen von einer bestimmten Gruppe von Adressen oder Bezeichnern des Netzwerks ein.
Für menschliche Benutzer (bei denen TYPEPERSON für den Benutzer angegeben ist) können Sie ein Token generieren, auch wenn der Benutzer keiner Netzwerkrichtlinie unterliegt. Der Benutzer muss jedoch einer Netzwerkrichtlinie unterliegen, um sich mit diesem Token authentifizieren zu können.
Wenn ein menschlicher Benutzer, der keiner Netzwerkrichtlinie unterliegt, ein programmatisches Zugriffstoken für die Authentifizierung verwenden muss, können Sie die Anforderung einer Netzwerkrichtlinie vorübergehend umgehen. Wir raten jedoch davon ab. Siehe Generierung eines programmatischen Zugriffstokens.
Bemerkung
Benutzer können die Netzwerkrichtlinie selbst nicht umgehen.
Die Netzwerkrichtlinie kann für alle Benutzer des Kontos oder für einen bestimmten Benutzer aktiviert werden.
Um diese Anforderung zu ändern, erstellen oder ändern Sie eine Authentifizierungsrichtlinie, die eine programmatische Access-Token-Richtlinie festlegt.
Führen Sie den Befehl CREATE AUTHENTICATION POLICY oder ALTER AUTHENTICATION POLICY aus. Setzen Sie NETWORK_POLICY_EVALUATION in der Klausel PAT_POLICY auf einen der folgenden Werte:
ENFORCED_REQUIRED
(Standard-Verhaltensweise)Der Benutzer muss einer Netzwerkrichtlinie unterliegen, um programmatische Zugriffstoken zu erstellen und zu verwenden.
Wenn der Benutzer einer Netzwerkrichtlinie unterliegt, wird die Netzwerkrichtlinie während der Authentifizierung durchgesetzt.
ENFORCED_NOT_REQUIRED
Der Benutzer muss nicht einer Netzwerkrichtlinie unterliegen, um programmatische Zugriffstoken zu erstellen und zu verwenden.
Wenn der Benutzer einer Netzwerkrichtlinie unterliegt, wird die Netzwerkrichtlinie während der Authentifizierung durchgesetzt.
NOT_ENFORCED
Der Benutzer muss nicht einer Netzwerkrichtlinie unterliegen, um programmatische Zugriffstoken zu erstellen und zu verwenden.
Wenn der Benutzer einer Netzwerkrichtlinie unterliegt, wird die Netzwerkrichtlinie nicht während der Authentifizierung durchgesetzt.
So können Sie beispielsweise eine Authentifizierungsrichtlinie erstellen, die die Netzwerkrichtlinienanforderung aufhebt, aber alle Netzwerkrichtlinien durchsetzt, denen der Benutzer unterliegt:
CREATE AUTHENTICATION POLICY my_authentication_policy
PAT_POLICY=(
NETWORK_POLICY_EVALUATION = ENFORCED_NOT_REQUIRED
);
Dann wenden Sie die Authentifizierungsrichtlinie auf ein Konto oder einen Benutzer an.
Ein weiteres Beispiel ist die Änderung einer bestehenden Authentifizierungsrichtlinie, um die Anforderung der Netzwerkrichtlinie zu entfernen und die Durchsetzung von Netzwerkrichtlinien zu verhindern, denen der Benutzer unterliegt:
ALTER AUTHENTICATION POLICY my_authentication_policy
SET PAT_POLICY = (
NETWORK_POLICY_EVALUATION = NOT_ENFORCED
);
Anforderungen der Authentifizierungsrichtlinie¶
Wenn es eine Authentifizierungsrichtlinie gibt, die die Authentifizierungsmethoden für einen Benutzer einschränkt, kann der Benutzer keine programmatischen Zugriffstoken erstellen und verwenden, es sei denn, die Liste der AUTHENTICATION_METHODS in dieser Richtlinie enthält 'PROGRAMMATIC_ACCESS_TOKEN'
.
Angenommen eine Authentifizierungsrichtlinie beschränkt die Benutzer auf die Methoden OAuth und Kennwort zur Authentifizierung:
CREATE AUTHENTICATION POLICY my_auth_policy
...
AUTHENTICATION_METHODS = ('OAUTH', 'PASSWORD')
...
Benutzer können keine programmgesteuerten Zugriffstoken erstellen und verwenden, wenn Sie 'PROGRAMMATIC_ACCESS_TOKEN'
nicht zur Liste AUTHENTICATION_METHODS hinzufügen. Sie können den Befehl ALTER AUTHENTICATION POLICY verwenden, um diese Liste zu aktualisieren.
Beispiel:
ALTER AUTHENTICATION POLICY my_auth_policy
SET AUTHENTICATION_METHODS = ('OAUTH', 'PASSWORD', 'PROGRAMMATIC_ACCESS_TOKEN');
Konfigurieren der Standard- und maximalen Ablaufzeit¶
Administratoren (Benutzer mit der Rolle ACCOUNTADMIN) können die folgenden Einstellungen konfigurieren, die sich auf die Ablaufzeit von programmatischen Zugriffstokens auswirken:
Festlegen der maximalen Ablaufzeit¶
Standardmäßig können Sie für ein Token eine Ablaufzeit von bis zu 365 Tagen angeben. Wenn Sie diese Zeitspanne verkürzen möchten, erstellen oder ändern Sie eine Authentifizierungsrichtlinie, die eine programmatische Zugriffstokenrichtlinie mit einer maximalen Ablaufzeit festlegt.
Führen Sie den Befehl CREATE AUTHENTICATION POLICY oder ALTER AUTHENTICATION POLICY aus. Setzen Sie in der Klausel PAT_POLICY MAX_EXPIRY_IN_DAYS auf einen Wert zwischen 1
und 365
.
Um beispielsweise eine Authentifizierungsrichtlinie zu erstellen, die das Maximum auf 100 Tage festlegt:
CREATE AUTHENTICATION POLICY my_authentication_policy
PAT_POLICY=(
MAX_EXPIRY_IN_DAYS=100
);
Dann wenden Sie die Authentifizierungsrichtlinie auf ein Konto oder einen Benutzer an.
Ein weiteres Beispiel: Sie möchten eine bestehende Authentifizierungsrichtlinie ändern und die Höchstdauer auf 90 Tage festlegen:
ALTER AUTHENTICATION POLICY my_authentication_policy
SET PAT_POLICY = (
MAX_EXPIRY_IN_DAYS=90
);
Bemerkung
Wenn es bereits programmatische Zugriffstoken mit Ablaufzeiten gibt, die die neue maximale Ablaufzeit überschreiten, schlägt der Versuch, sich mit diesen Token zu authentifizieren, fehl.
Nehmen wir zum Beispiel an, dass Sie ein programmatisches Zugriffstoken mit dem Namen my_token
und einer Gültigkeitsdauer von 7 Tagen erstellen. Wenn Sie später die maximale Ablaufzeit für alle Token auf 2 Tage ändern, schlägt die Authentifizierung mit my_token
fehl, weil die Ablaufzeit des Tokens die neue maximale Ablaufzeit überschreitet.
Festlegen der Standardablaufzeit¶
Standardmäßig läuft ein programmatisches Zugriffstoken nach 15 Tagen ab. Wenn Sie dies ändern möchten, erstellen oder ändern Sie eine Authentifizierungsrichtlinie, die eine programmatische Zugriffstoken-Richtlinie mit einem Standardablaufdatum angibt.
Führen Sie den Befehl CREATE AUTHENTICATION POLICY oder ALTER AUTHENTICATION POLICY aus. Legen Sie in der Klausel PAT_POLICY DEFAULT_EXPIRY_IN_DAYS auf einen Wert zwischen 1
und der maximalen Verfallszeit <label-pat_maximum_expiration_time> fest.
Um beispielsweise eine Authentifizierungsrichtlinie zu erstellen, die das Maximum auf 5 Tage festlegt:
CREATE AUTHENTICATION POLICY my_authentication_policy
PAT_POLICY=(
DEFAULT_EXPIRY_IN_DAYS=5
);
Dann wenden Sie die Authentifizierungsrichtlinie auf ein Konto oder einen Benutzer an.
Ein weiteres Beispiel: Sie möchten eine bestehende Authentifizierungsrichtlinie ändern, um die Standardeinstellung auf 30 Tage zu setzen:
ALTER AUTHENTICATION POLICY my_authentication_policy
SET PAT_POLICY = (
DEFAULT_EXPIRY_IN_DAYS=30
);
Erforderliche Berechtigungen für programmatische Zugriffstoken¶
Um ein programmatisches Zugriffstoken zu erstellen und zu verwalten, müssen Sie eine Rolle verwenden, die über die folgenden Berechtigungen verfügt:
Für menschliche Benutzer (mit TYPE=PERSON) benötigen Sie keine besonderen Berechtigungen, um ein programmatisches Zugriffstoken für sich selbst zu erzeugen, zu ändern, zu löschen oder anzuzeigen.
Wenn Sie ein programmatisches Zugriffstoken für einen anderen Benutzer oder einen Dienstbenutzer (mit TYPE=SERVICE erstellen, ändern, löschen oder anzeigen, müssen Sie eine Rolle verwenden, die über die Berechtigung OWNERSHIP oder MODIFY PROGRAMMATIC AUTHENTICATION METHODS für diesen Benutzer verfügt.
Angenommen, Sie möchten Benutzern mit der benutzerdefinierten Rolle
my_service_owner_role
die Möglichkeit geben, programmatische Zugriffstoken für den Dienstbenutzermy_service_user
zu erstellen und zu verwalten. Sie können der Rollemy_service_owner_role
die Berechtigung MODIFY PROGRAMMATIC AUTHENTICATION METHODS für den Benutzermy_service_user
erteilen:GRANT MODIFY PROGRAMMATIC AUTHENTICATION METHODS ON USER my_service_user TO ROLE my_service_owner_role;
Generierung eines programmatischen Zugriffstokens¶
Sie können ein programmatisches Zugriffstoken in Snowsight oder durch die Ausführung von SQL-Befehlen erzeugen.
Melden Sie sich bei Snowsight an.
Wählen Sie Admin » Users & Roles aus.
Wählen Sie den Benutzer, für den Sie das programmatische Zugriffstoken erstellen möchten.
Wählen Sie unter Programmatic access tokens die Option Generate new token aus.
Geben Sie im Dialog New programmatic access token die folgenden Informationen ein:
Geben Sie in das Feld Name einen Namen für das Token ein.
Im Namen können Sie nur Buchstaben, Zahlen und Unterstriche verwenden. Der Name muss mit einem Buchstaben oder einem Unterstrich beginnen. Die Buchstaben im Namen werden als Großbuchstaben gespeichert und aufgelöst.
Geben Sie in das Feld Comment einen beschreibenden Kommentar zu dem Token ein.
Nachdem Sie das Token erstellt haben, wird dieser Kommentar unter dem Token im Bereich Programmatic access tokens angezeigt.
Wählen Sie unter Expires in die Anzahl der Tage, nach denen das Token ablaufen soll.
Wenn Sie das Token im Namen eines Benutzers für einen Dienst erstellen (wenn das Objekt USER TYPE=SERVICEhat) oder wenn Sie den Umfang der durchführbaren Operationen einschränken möchten, wählen Sie One specific role (recommended), und wählen Sie dann die Rolle, die für die Berechtigungsprüfung und die Objekterstellung verwendet werden soll.
Wenn Sie dieses Token für die Authentifizierung verwenden, gehören alle Objekte, die Sie erstellen, dieser Rolle, und diese Rolle wird für die Berechtigungsprüfung verwendet.
Bemerkung
Sekundärrollen werden nicht verwendet, auch wenn DEFAULT_SECONDARY_ROLES für den Benutzer auf (‚ALL‘) eingestellt ist.
Wenn Sie stattdessen Any of my roles wählen, werden alle Objekte, die Sie erstellen und die Ihrer primären Rolle gehören, und Berechtigungen gegen Ihre aktiven Rollen ausgewertet.
Wählen Sie Generate aus.
Kopieren oder laden Sie das generierte programmatische Zugriffstoken herunter, damit Sie das Token für die Authentifizierung verwenden können.
Bemerkung
Nachdem Sie dieses Meldungsfeld geschlossen haben, können Sie dieses Token nicht mehr kopieren oder herunterladen.
Das neue Token ist im Abschnitt Programmatic access tokens aufgeführt.
Wie bereits erwähnt, muss der Benutzer, der mit dem Token verbunden ist, einer Netzwerkrichtlinie unterliegen, um ein programmatisches Zugriffstoken zu verwenden, es sei denn, Sie richten eine Authentifizierungsrichtlinie ein, die diese Anforderung ändert.
Wenn ein menschlicher Benutzer, der keiner Netzwerkrichtlinie unterliegt, ein programmatisches Zugriffstoken zur Authentifizierung verwenden muss, können Sie die Anforderung einer Netzwerkrichtlinie vorübergehend umgehen, indem Sie » Bypass requirement for network policy auswählen.
Bemerkung
Bypass requirement for network policy erlaubt es Benutzern nicht, die Netzwerkrichtlinie selbst zu umgehen.
Führen Sie ALTER USER … ADD PROGRAMMATIC ACCESS TOKEN (PAT) aus, und geben Sie einen Namen für das Token an.
Wenn Sie den Token für sich selbst generieren, lassen Sie den Parameter
username
weg. Um beispielsweise ein Token mit dem Namenexample_token
zu generieren:ALTER USER ADD PROGRAMMATIC ACCESS TOKEN example_token;
Wenn Sie das Token im Namen eines Benutzers für eine Person erzeugen (wenn das Objekt USER TYPE=PERSONhat), geben Sie den Namen des Benutzers an. Um zum Beispiel ein Token mit dem Namen
example_token
für den Benutzerexample_user
zu erzeugen:ALTER USER IF EXISTS example_user ADD PROGRAMMATIC ACCESS TOKEN example_token;
Tipp
Sie können das Schlüsselwort PAT als eine kürzere Form der Angabe der Schlüsselwörter PROGRAMMATIC ACCESS TOKEN verwenden.
Beachten Sie Folgendes:
Wenn Sie das Token im Namen eines Benutzers für einen Dienst erzeugen (wenn das Objekt USER TYPE=SERVICEhat) oder wenn Sie den Umfang der durchführbaren Operationen einschränken möchten, setzen Sie ROLE_RESTRICTION auf die Rolle, die für die Berechtigungsprüfung und die Objekterstellung verwendet werden soll.
Dies muss eine Rolle sein, die dem Benutzer zugewiesen wurde. Sie können diese Rolle nur bei der Erstellung des Tokens angeben.
Wenn Sie dieses Token für die Authentifizierung verwenden, gehören alle Objekte, die Sie erstellen, dieser Rolle, und diese Rolle wird für die Berechtigungsprüfung verwendet.
Bemerkung
Sekundärrollen werden nicht verwendet, auch wenn DEFAULT_SECONDARY_ROLES für den Benutzer auf (‚ALL‘) eingestellt ist.
Angenommen, Sie möchten beispielsweise für den Benutzer des Dienstes
example_service_user
ein Token mit dem Namenexample_service_user_token
erzeugen. Wenn sich der Dienstbenutzer mit diesem Token authentifiziert, sollte die Rolleexample_service_user_role
(die diesem Dienstbenutzer gewährt wurde) verwendet werden, um Berechtigungen zu prüfen und alle vom Benutzer erstellten Objekte zu besitzen.Um ein Token für diesen Fall zu erzeugen, führen Sie die folgende Anweisung aus:
ALTER USER IF EXISTS example_service_user ADD PROGRAMMATIC ACCESS TOKEN example_service_user_token ROLE_RESTRICTION = 'example_service_user_role';
Wenn Sie ROLE_RESTRICTION weglassen, werden alle Objekte, die Sie mit Ihrer primären Rolle erstellen, sowie Berechtigungen anhand Ihrer aktiven Rollen bewertet.
Um festzulegen, wann das Token ablaufen soll (und damit die Standardablaufzeit überschreibt), setzen Sie den Parameter DAYS_TO_EXPIRY auf die Anzahl der Tage, nach denen das Token ablaufen soll.
Sie können einen Wert von
1
(für 1 Tag) bis zum Wert der maximalen Ablaufzeit angeben.Zum Beispiel, um ein programmatisches Zugriffstoken zu erzeugen, das nach 10 Tagen abläuft:
ALTER USER IF EXISTS example_user ADD PROGRAMMATIC ACCESS TOKEN example_token DAYS_TO_EXPIRY = 10 COMMENT = 'An example of a token that expires in 10 days';
Wie bereits erwähnt, muss der Benutzer, der mit dem Token verbunden ist, einer Netzwerkrichtlinie unterliegen, um ein programmatisches Zugriffstoken zu verwenden, es sei denn, Sie richten eine Authentifizierungsrichtlinie ein, die diese Anforderung ändert.
Für menschliche Benutzer (mit dem Benutzer-TYPE PERSON), die keiner Netzwerkrichtlinie unterliegen, können Sie die Anforderung einer Netzwerkrichtlinie vorübergehend umgehen, indem Sie MINS_TO_BYPASS_NETWORK_POLICY_REQUIREMENT auf die Anzahl der Minuten setzen, für die Sie diese Anforderung umgehen möchten.
Nehmen wir beispielsweise an, Sie sind ein Benutzer, der keiner Netzwerkrichtlinie unterliegt, und Sie möchten ein programmatisches Zugriffstoken für die Authentifizierung verwenden. Sie können die Anforderung einer Netzwerkrichtlinie für 4 Stunden umgehen, indem Sie MINS_TO_BYPASS_NETWORK_POLICY_REQUIREMENT auf 240 setzen.
Bemerkung
Die Einstellung MINS_TO_BYPASS_NETWORK_POLICY_REQUIREMENT erlaubt es Benutzern nicht, die Netzwerkrichtlinie selbst zu umgehen.
ALTER USER … ADD PROGRAMMATIC ACCESS TOKEN gibt das Token in der Spalte token_secret
in der Ausgabe aus:
+---------------+-----------------+
| token_name | token_secret |
|---------------+-----------------|
| EXAMPLE_TOKEN | ... (token) ... |
+---------------+-----------------+
Bemerkung
Die Ausgabe dieses Befehls ist der einzige Ort, an dem das Token erscheint. Kopieren Sie das Token aus der Ausgabe zur Verwendung bei der Authentifizierung an einem Endpunkt.
Nachdem Sie ein programmatisches Zugriffstoken erstellt haben, können Sie das Ablaufdatum nicht mehr ändern. Sie müssen den Token widerrufen und einen neuen Token mit der neuen Ablaufzeit erstellen.
Wenn Sie eine Rolle für das programmatische Zugriffstoken angegeben haben und diese Rolle dem Benutzer entzogen wird, verwendet das programmatische Zugriffstoken die Systemrolle PUBLIC.
Verwendung eines programmatischen Zugriffstokens¶
In den folgenden Abschnitten wird erläutert, wie Sie ein programmatisches Zugriffstoken als Kennwort und für die Authentifizierung an einem Snowflake Endpunkt verwenden:
Verwendung eines programmatischen Zugriffstokens als Kennwort
Verwendung eines programmatischen Zugriffstokens zur Authentifizierung bei einem Endpunkt
Verwendung eines programmatischen Zugriffstokens als Kennwort¶
Um sich mit einem programmatischen Zugriffstoken als Kennwort zu authentifizieren, können Sie den Token als Wert für das Kennwort in den Treibereinstellungen oder im Aufruf zum Herstellen einer Verbindung mit Snowflake angeben.
Wenn Sie zum Beispiel den Snowflake Connector für Python verwenden, können Sie das programmatische Zugriffstoken als password
Argument angeben, wenn Sie die Methode snowflake.connector.connect
aufrufen.
conn = snowflake.connector.connect(
user=USER,
password=<programmatic_access_token>,
account=ACCOUNT,
warehouse=WAREHOUSE,
database=DATABASE,
schema=SCHEMA
)
Auf die gleiche Weise können Sie in Anwendungen von Drittanbietern (wie Tableau oder PowerBI) programmatische Zugriffstoken anstelle eines Kennworts verwenden. Fügen Sie das programmatische Zugriffstoken in das Feld für das Kennwort ein.
Bemerkung
Standardmäßig muss für die Verwendung von programmatischen Zugriffstokens eine Netzwerkrichtlinie für einen Benutzer oder für alle Benutzer des Kontos aktiviert werden. Um programmatische Zugriffstoken mit einer Anwendung eines Drittanbieters zu verwenden, müssen Sie eine Netzwerkrichtlinie erstellen, die Anfragen aus den IP-Adressbereichen der Anwendung des Drittanbieters zulässt.
Verwendung eines programmatischen Zugriffstokens zur Authentifizierung bei einem Endpunkt¶
Um sich mit einem programmatischen Zugriffstoken zu authentifizieren, setzen Sie die folgenden HTTP-Header in der Anfrage:
Authorization: Bearer token_secret
X-Snowflake-Authorization-Token-Type: PROGRAMMATIC_ACCESS_TOKEN
(optional)
Wenn Sie zum Beispiel cURL verwenden, um eine Anfrage an einen Snowflake REST-API-Endpunkt zu senden:
curl --location 'https://myorganization-myaccount.snowflakecomputing.com/api/v2/databases' \
--header "Authorization: Bearer <token_secret>"
Ein weiteres Beispiel: Sie verwenden cURL, um eine Anfrage an den Snowflake SQL API-Endpunkt zu senden:
curl -si -X POST https://myorganization-myaccount.snowflakecomputing.com/api/v2/statements \
--header "Content-Type: application/json" \
--header "Accept: application/json" \
--header "Authorization: Bearer <token_secret>" \
--data '{"statement": "select 1"}'
Wenn die Anfrage mit einem PAT_INVALID
-Fehler fehlschlägt, kann der Fehler aus einem der folgenden Gründe aufgetreten sein:
Der Benutzer, der mit dem programmatischen Zugriffstoken verbunden ist, wurde nicht gefunden.
Validierung fehlgeschlagen.
Die mit dem programmatischen Zugriffstoken verbundene Rolle wurde nicht gefunden.
Der Benutzer ist nicht mit dem angegebenen programmatischen Zugriffstoken verbunden.
Programmatische Zugriffstoken verwalten¶
In den folgenden Abschnitten wird erklärt, wie Sie programmatische Zugriffstoken verwenden, ändern, auflisten, rotieren und widerrufen können:
Bemerkung
Sie können einen programmatischen Zugriffstoken in einer Sitzung, in der Sie einen programmatischen Zugriffstoken zur Authentifizierung verwendet haben, nicht ändern, umbenennen, drehen oder widerrufen.
Auflistung der programmatischen Zugriffstoken¶
Sie können das programmatische Zugriffstoken für einen Benutzer in Snowsight auflisten oder indem Sie SQL-Befehle ausführen.
Melden Sie sich bei Snowsight an.
Wählen Sie Admin » Users & Roles aus.
Wählen Sie den Benutzer, der das programmatische Zugriffstoken besitzt.
Die programmatischen Zugriffstoken für den Benutzer sind unter Programmatic access tokens aufgeführt.
Führen Sie den Befehl SHOW USER PROGRAMMATIC ACCESS TOKENS aus. Zum Beispiel, um Informationen über die programmatischen Zugriffstoken anzuzeigen, die mit dem Benutzer example_user
verbunden sind:
SHOW USER PROGRAMMATIC ACCESS TOKENS FOR USER example_user;
Bemerkung
Nach sieben Tagen werden abgelaufene programmatische Zugriffstoken gelöscht und erscheinen nicht mehr unter Snowsight oder in der Ausgabe des Befehls SHOW USER PROGRAMMATIC ACCESS TOKENS.
Umbenennen eines programmatischen Zugriffstokens¶
Sie können den Namen eines programmatischen Zugriffstokens in Snowsight oder durch die Ausführung von SQL-Befehlen ändern.
Melden Sie sich bei Snowsight an.
Wählen Sie Admin » Users & Roles aus.
Wählen Sie den Benutzer, der mit dem programmatischen Zugriffstoken verbunden ist.
Suchen Sie unter Programmatic access tokens das programmatische Zugriffstoken und wählen Sie
» Edit.
Ändern Sie im Feld Name den Namen des Tokens, und wählen Sie Save.
Ausführen ALTERUSER … MODIFYPROGRAMMATICACCESSTOKEN … RENAMETO. Beispiel:
ALTER USER IF EXISTS example_user MODIFY PROGRAMMATIC ACCESS TOKEN old_token_name RENAME TO new_token_name;
Rotieren eines programmatischen Zugangstokens¶
Sie können ein programmatisches Zugriffstoken in Snowsight oder durch die Ausführung von SQL-Befehlen rotieren.
Das Rotieren eines Tokens liefert ein neues Token-Geheimnis, das denselben Namen und eine verlängerte Ablaufzeit hat. Durch das Rotieren eines Tokens erlischt auch das bestehende Token-Geheimnis. Verwenden Sie das neue Token für die Authentifizierung bei Snowflake.
Melden Sie sich bei Snowsight an.
Wählen Sie Admin » Users & Roles aus.
Wählen Sie den Benutzer, der mit dem programmatischen Zugriffstoken verbunden ist.
Suchen Sie unter Programmatic access tokens das programmatische Zugriffstoken und wählen Sie
» Rotate.
Wenn Sie möchten, dass das vorherige Token-Geheimnis sofort abläuft, wählen Sie Expire current secret immediately.
Wählen Sie Rotate token aus.
Kopieren oder laden Sie das generierte programmatische Zugriffstoken herunter, damit Sie das Token für die Authentifizierung verwenden können.
Bemerkung
Nachdem Sie dieses Meldungsfeld geschlossen haben, können Sie dieses Token nicht mehr kopieren oder herunterladen.
Führen Sie den Befehl ALTER USER … ROTATE PROGRAMMATIC ACCESS TOKEN (PAT) aus.
Zum Beispiel, um das mit dem Benutzer example_user
verbundene programmatische Zugriffstoken example_token
zu drehen:
ALTER USER IF EXISTS example_user ROTATE PROGRAMMATIC ACCESS TOKEN example_token;
Wenn Sie festlegen möchten, wann das alte Token abläuft, setzen Sie EXPIRE_ROTATED_TOKEN_AFTER_HOURS auf die Anzahl der Stunden, bevor das alte Token ablaufen soll. Zum Beispiel, um das alte Token sofort ablaufen zu lassen:
ALTER USER IF EXISTS example_user
ROTATE PROGRAMMATIC ACCESS TOKEN example_token
EXPIRE_ROTATED_TOKEN_AFTER_HOURS = 0;
Der Befehl gibt das Token in der Spalte token_secret
der Ausgabe aus:
+---------------+-----------------+-------------------------------------+
| token_name | token_secret | rotated_token_name |
|---------------+-----------------+-------------------------------------|
| EXAMPLE_TOKEN | ... (token) ... | EXAMPLE_TOKEN_ROTATED_1744239049066 |
+---------------+-----------------+-------------------------------------+
Bemerkung
Die Ausgabe dieses Befehls ist der einzige Ort, an dem das neue Token erscheint. Kopieren Sie das Token aus der Ausgabe zur Verwendung bei der Authentifizierung an einem Endpunkt.
Die Ausgabe enthält auch den Namen des älteren Tokens, das rotiert wurde:
Wenn Sie wissen möchten, wann dieses Token abläuft, können Sie den Befehl SHOW USER PROGRAMMATIC ACCESS TOKENS verwenden und nach dem Namen des Tokens suchen. Beispiel:
SHOW USER PROGRAMMATIC ACCESS TOKENS FOR USER example_user;
+--------------------------------------+--------------+------------------+-------------------------------+---------+---------+-------------------------------+--------------+-------------------------------------------+----------------+ | name | user_name | role_restriction | expires_at | status | comment | created_on | created_by | mins_to_bypass_network_policy_requirement | rotated_to | |--------------------------------------+--------------+------------------+-------------------------------+---------+---------+-------------------------------+--------------+-------------------------------------------+----------------| | EXAMPLE_TOKEN | EXAMPLE_USER | MY_CUSTOM_ROLE | 2025-05-09 07:18:47.360 -0700 | ACTIVE | | 2025-04-09 07:18:47.360 -0700 | EXAMPLE_USER | NULL | NULL | | EXAMPLE_TOKEN_ROTATED_1744239049066 | EXAMPLE_USER | MY_CUSTOM_ROLE | 2025-04-10 15:21:49.652 -0700 | ACTIVE | | 2025-04-09 15:21:49.652 -0700 | EXAMPLE_USER | NULL | EXAMPLE_TOKEN | +--------------------------------------+--------------+------------------+-------------------------------+---------+---------+-------------------------------+--------------+-------------------------------------------+----------------+
Wenn Sie dieses Token widerrufen möchten, können Sie den Befehl ALTER USER … REMOVE PROGRAMMATIC ACCESS TOKEN (PAT) verwenden und den Namen des älteren Tokens angeben. Beispiel:
ALTER USER IF EXISTS example_user REMOVE PROGRAMMATIC ACCESS TOKEN EXAMPLE_TOKEN_ROTATED_1744239049066;
+-------------------------------------------------------------------------------------+ | status | |-------------------------------------------------------------------------------------| | Programmatic access token EXAMPLE_TOKEN_ROTATED_1744239049066 successfully removed. | +-------------------------------------------------------------------------------------+
Widerrufen eines programmatischen Zugriffstokens¶
Sie können ein programmatisches Zugriffstoken in Snowsight oder durch die Ausführung von SQL-Befehlen widerrufen.
Melden Sie sich bei Snowsight an.
Wählen Sie Admin » Users & Roles aus.
Wählen Sie den Benutzer, der mit dem programmatischen Zugriffstoken verbunden ist.
Suchen Sie unter Programmatic access tokens das programmatische Zugriffstoken und wählen Sie
» Delete.
Führen Sie den Befehl ALTER USER … REMOVE PROGRAMMATIC ACCESS TOKEN (PAT) aus.
Zum Beispiel, um das programmatische Zugriffstoken example_token
zu widerrufen, das mit dem Benutzer example_user
verbunden ist:
ALTER USER IF EXISTS example_user REMOVE PROGRAMMATIC ACCESS TOKEN example_token;
Deaktiviertes programmatisches Zugriffstoken wieder aktivieren¶
Wenn Sie den Anmeldezugang für einen Benutzer deaktivieren oder Snowflake einen Benutzer für die Anmeldung sperrt, werden die programmatischen Zugriffstoken für diesen Benutzer automatisch deaktiviert.
Bemerkung
Programmatische Zugriffstoken werden nicht deaktiviert, wenn ein Benutzer vorübergehend gesperrt ist (z. B. aufgrund von fünf oder mehr fehlgeschlagenen Authentifizierungsversuchen).
Wenn Sie den Befehl SHOW USER PROGRAMMATIC ACCESS TOKENS ausführen, lautet der Wert in der Spalte status
für die mit diesem Benutzer verbundenen Token DISABLED
.
SHOW USER PROGRAMMATIC ACCESS TOKENS FOR USER example_user;
+---------------+--------------+------------------+-------------------------------+----------+---------+-------------------------------+--------------+-------------------------------------------+------------+
| name | user_name | role_restriction | expires_at | status | comment | created_on | created_by | mins_to_bypass_network_policy_requirement | rotated_to |
|---------------+--------------+------------------+-------------------------------+----------+---------+-------------------------------+--------------+-------------------------------------------+------------|
| EXAMPLE_TOKEN | EXAMPLE_USER | MY_ROLE | 2025-04-28 12:13:46.431 -0700 | DISABLED | NULL | 2025-04-13 12:13:46.431 -0700 | EXAMPLE_USER | NULL | NULL |
+---------------+--------------+------------------+-------------------------------+----------+---------+-------------------------------+--------------+-------------------------------------------+------------+
Wenn Sie später den Anmeldezugang für diesen Benutzer aktivieren oder Snowflake den Anmeldezugang für diesen Benutzer entsperrt, bleiben die programmatischen Zugangstoken für diesen Benutzer deaktiviert. Um die Token wieder zu aktivieren, führen Sie den Befehl ALTER USER … MODIFY PROGRAMMATIC ACCESS TOKEN (PAT) aus, und setzen Sie DISABLED auf FALSE. Beispiel:
ALTER USER example_user MODIFY PROGRAMMATIC ACCESS TOKEN example_token SET DISABLED = FALSE;
Abrufen von Informationen über ein programmatisches Zugriffstoken aus dem Geheimnis¶
Wenn Sie Informationen über ein programmatisches Zugriffstoken benötigen, rufen Sie die Funktion SYSTEM$DECODE_PAT auf, wenn Sie das Geheimnis für dieses Token kennen. Sie können diese Funktion verwenden, wenn das Geheimnis kompromittiert wurde und Sie den mit dem Token verbundenen Benutzer, den Namen des Tokens und den Status des Tokens erfahren möchten.
Beispiel:
SELECT SYSTEM$DECODE_PAT('abC...Y5Z');
+------------------------------------------------------------------------+
| SYSTEM$DECODE_PAT('☺☺☺...☺☺☺') |
|------------------------------------------------------------------------|
| {"STATE":"ACTIVE","PAT_NAME":"MY_EXAMPLE_TOKEN","USER_NAME":"MY_USER"} |
+------------------------------------------------------------------------+
Best Practices¶
Wenn Sie ein programmatisches Zugriffstoken speichern müssen, tun Sie dies auf sichere Weise (z. B. mit einem Kennwort- oder Geheimnismanager).
Vermeiden Sie die Offenlegung von programmatischen Zugriffstoken im Code.
Beschränken Sie die Verwendung des Tokens bei der Erstellung des Tokens auf eine bestimmte Rolle.
Überprüfen und wechseln Sie regelmäßig die programmatischen Zugangstoken. Benutzer können die Ablaufzeit bei der Erstellung des Tokens <label-pat_generate> festlegen, und Administratoren können die maximale Ablaufzeit für alle Token reduzieren, um die Rotation der Token zu fördern.
Einschränkungen¶
Sie können ein programmatisches Zugriffstoken nur auf eine Rolle beschränken, wenn Sie das Token erzeugen. Nachdem Sie das Token erstellt haben, können Sie die Rolle, auf die es beschränkt ist, nicht mehr ändern oder entfernen.
Sie können die Ablaufzeit für ein programmatisches Zugriffstoken nur festlegen, wenn Sie das Token generieren. Nachdem Sie dasToken generiert haben, können Sie die Ablaufzeit nicht mehr ändern. Sie können ein programmatisches Zugriffstoken widerrufen und ein neues Token mit einer anderen Ablaufzeit erzeugen.
Sie können das Geheimnis für ein programmatisches Zugriffstoken nur sehen, wenn Sie es erstellen. Nachdem Sie ein programmatisches Zugriffstoken erstellt haben, können Sie nur Informationen über das Token und nicht das Geheimnis für das Token einsehen.
Administratoren können alle programmatischen Zugriffstoken für einen bestimmten Benutzer auflisten, jedoch nicht alle programmatischen Zugriffstoken für ein Konto.
Sie können ein programmatisches Zugriffstoken nicht wiederherstellen, nachdem Sie es widerrufen haben.