Tutorial 1: Snowpark Container Services-Dienst erstellen¶
Einführung¶
Nachdem Sie die grundlegende Einrichtung abgeschlossen haben, können Sie nun einen Dienst erstellen. In diesem Tutorial erstellen Sie einen Dienst (mit dem Namen echo_service
), der einfach den von Ihnen eingegebenen Text als Echo wieder zurückgibt. Wenn die Eingabezeichenfolge beispielsweise „Hello World“ ist, gibt der Dienst „I said, Hello World“ zurück.
Dieses Tutorial besteht aus zwei Teilen:
Teil 1: Dienst erstellen und testen. Sie laden den für dieses Tutorial bereitgestellten Code herunter und befolgen die schrittweise Anleitung:
Dienstcode für dieses Tutorial herunterladen
Docker-Image für Snowpark Container Services erstellen und Image in Repository im eigenen Konto hochladen
Dienst erstellen, indem die Dienstspezifikationsdatei und der Computepool für die Ausführung des Dienstes bereitgestellt werden
Dienstfunktion für die Kommunikation mit dem Dienst bereitstellen
Dienst einsetzen. Dazu wird eine Echo-Anforderung an den Dienst gesendet und die Antwort überprüft.
Teil 2: Erläuterungen zum Dienst. Dieser Abschnitt bietet eine Übersicht zum Dienstcode und zeigt auf, wie die verschiedenen Komponenten zusammenarbeiten.
1: Dienstcode herunterladen¶
Zum Erstellen des Echo-Dienstes wird ein Code (eine Python-Anwendung) bereitgestellt.
Laden Sie die ZIP-Datei in ein Verzeichnis herunter.
Entpacken Sie den Inhalt, der ein Verzeichnis für jedes Tutorial enthält. Das Verzeichnis
Tutorial-1
enthält die folgenden Dateien:Dockerfile
echo_service.py
templates/basic_ui.html
2: Image erstellen und hochladen¶
Erstellen Sie ein Image für die linux/amd64-Plattform, die von Snowpark Container Services unterstützt wird, und laden Sie das Image dann in das Image-Repository in Ihrem Konto hoch (siehe Grundlegende Einrichtung).
Sie benötigen Informationen zum Repository (die Repository-URL und den Hostnamen der Registry), bevor Sie das Image erstellen und hochladen können. Weitere Informationen dazu finden Sie unter Registry und Repositorys.
Informationen zum Repository abrufen
Um die Repository-URL zu erhalten, führen Sie den SQL-Befehl SHOW IMAGE REPOSITORIES aus.
SHOW IMAGE REPOSITORIES;
Die URL ist in der Spalte
repository_url
der Ausgabe enthalten. Siehe folgendes Beispiel:<orgname>-<acctname>.registry.snowflakecomputing.com/tutorial_db/data_schema/tutorial_repository
Der Hostname in der Repository-URL ist der Name des Registry-Hosts. Siehe folgendes Beispiel:
<orgname>-<acctname>.registry.snowflakecomputing.com
Image erstellen und in das Repository hochladen
Öffnen Sie ein Terminalfenster, und wechseln Sie in das Verzeichnis, das die entpackten Dateien enthält.
Um ein Docker-Image zu erstellen, führen Sie den folgenden Befehl
docker build
mithilfe der Docker-CLI aus. Beachten Sie, dass der Befehl das aktuelle Arbeitsverzeichnis (.) alsPATH
für die Dateien angibt, die für das Erstellen des Images verwendet werden sollen.docker build --rm --platform linux/amd64 -t <repository_url>/<image_name> .
Für
image_name
verwenden Siemy_echo_service_image:latest
:
Beispiel
docker build --rm --platform linux/amd64 -t myorg-myacct.registry.snowflakecomputing.com/tutorial_db/data_schema/tutorial_repository/my_echo_service_image:latest .
Laden Sie das Image in das Repository in Ihrem Snowflake-Konto hoch. Damit Docker ein Image in Ihrem Namen in Ihr Repository hochladen kann, müssen Sie Docker zunächst mit Snowflake authentifizieren.
Um Docker bei der Snowflake-Registrierung zu authentifizieren, führen Sie den folgenden Befehl aus.
docker login <registry_hostname> -u <username>
Geben Sie dabei für
username
Ihren Snowflake-Benutzernamen an. Docker fordert Sie zur Eingabe Ihres Kennworts auf.
Führen Sie den folgenden Befehl aus, um das Image hochzuladen:
docker push <repository_url>/<image_name>
Beispiel
docker push myorg-myacct.registry.snowflakecomputing.com/tutorial_db/data_schema/tutorial_repository/my_echo_service_image:latest
3: Dienst erstellen¶
In diesem Abschnitt erstellen Sie einen Dienst und dann eine Dienstfunktion, die mit dem Dienst kommuniziert.
Um einen Dienst zu erstellen, benötigen Sie Folgendes:
Einen Computepool. Snowflake führt Ihren Dienst in dem angegebenen Computepool aus. Sie haben einen Computepool als Teil der grundlegenden Einrichtung erstellt.
Eine Dienstspezifikation. Diese Spezifikation liefert Snowflake die Informationen, die zur Konfiguration und Ausführung Ihres Dienstes erforderlich sind. Weitere Informationen dazu finden Sie unter Snowpark Container Services: Verwenden von Diensten. In diesem Tutorial geben Sie die Spezifikation inline im Befehl CREATE SERVICE an. Sie können die Spezifikation auch in einer Datei in Ihrem Snowflake-Stagingbereich speichern und die Dateiinformationen im Befehl CREATE SERVICE bereitstellen, wie in Tutorial 2 gezeigt.
Eine Dienstfunktion ist eine der verfügbaren Methoden zur Kommunikation mit Ihrem Dienst. Eine Dienstfunktion ist eine benutzerdefinierte Funktion (UDF), die Sie mit dem Dienstendpunkt verknüpfen. Wenn die Dienstfunktion ausgeführt wird, sendet sie eine Anforderung an den Dienstendpunkt und erhält eine Antwort.
Überprüfen Sie, ob der Computepool bereit ist und ob Sie sich im korrekten Kontext befinden, um den Dienst zu erstellen.
Zuvor haben Sie den Kontext im Schritt Grundlegende Einrichtung festgelegt. Um sicherzustellen, dass Sie sich in diesem Schritt im korrekten Kontext für die SQL-Anweisungen befinden, führen Sie Folgendes aus:
USE ROLE test_role; USE DATABASE tutorial_db; USE SCHEMA data_schema; USE WAREHOUSE tutorial_warehouse;
Um sicherzustellen, dass der unter Grundlegende Einrichtung erstellte Computepool bereit ist, führen Sie
DESCRIBE COMPUTE POOL
aus, und überprüfen Sie dann, obstate
den WertACTIVE
oderIDLE
hat. Wenn diestate
den WertSTARTING
hat, müssen Sie warten, bisstate
entwederACTIVE
oderIDLE
ist.
DESCRIBE COMPUTE POOL tutorial_compute_pool;
Um den Dienst zu erstellen, führen Sie mit der Rolle
test_role
den folgenden Befehl aus:CREATE SERVICE echo_service IN COMPUTE POOL tutorial_compute_pool FROM SPECIFICATION $$ spec: containers: - name: echo image: /tutorial_db/data_schema/tutorial_repository/my_echo_service_image:latest env: SERVER_PORT: 8000 CHARACTER_NAME: Bob readinessProbe: port: 8000 path: /healthcheck endpoints: - name: echoendpoint port: 8000 public: true $$ MIN_INSTANCES=1 MAX_INSTANCES=1;
Bemerkung
Wenn bereits ein Dienst mit diesem Namen existiert, verwenden Sie den Befehl DROP SERVICE, um den zuvor erstellten Dienst zu löschen, und erstellen Sie dann diesen Dienst.
Führen Sie die folgenden SQL-Befehle aus, um detaillierte Informationen zu dem gerade erstellten Dienst zu erhalten. Weitere Informationen dazu finden Sie unter Snowpark Container Services: Verwenden von Diensten.
Um die Dienste in Ihrem Konto aufzulisten, führen Sie den Befehl SHOW SERVICES aus:
SHOW SERVICES;
Um den Status Ihres Dienstes zu erfahren, rufen Sie die Systemfunktion SYSTEM$GET_SERVICE_STATUS auf:
SELECT SYSTEM$GET_SERVICE_STATUS('echo_service');
Um Informationen zu Ihrem Dienst zu erhalten, führen Sie den Befehl DESCRIBE SERVICE aus:
DESCRIBE SERVICE echo_service;
Um eine Dienstfunktion zu erstellen, führen Sie den folgenden Befehl aus:
CREATE FUNCTION my_echo_udf (InputText varchar) RETURNS varchar SERVICE=echo_service ENDPOINT=echoendpoint AS '/echo';
Beachten Sie Folgendes:
Die Eigenschaft SERVICE verknüpft die UDF mit dem Dienst
echo_service
.Die Eigenschaft ENDPOINT verknüpft die UDF mit dem Endpunkt
echoendpoint
innerhalb des Dienstes.„AS ‚/echo‘“ gibt den HTTP-Pfad zum Echo-Server an. Sie finden diesen Pfad im Dienstcode (
echo_service.py
).
4: Dienst einsetzen¶
Richten Sie zunächst den Kontext für die SQL-Anweisungen in diesem Abschnitt ein, indem Sie Folgendes ausführen:
USE ROLE test_role;
USE DATABASE tutorial_db;
USE SCHEMA data_schema;
USE WAREHOUSE tutorial_warehouse;
Jetzt können Sie mit dem Echo-Dienst kommunizieren.
Verwenden einer Dienstfunktion: Sie können die Dienstfunktion in einer Abfrage aufrufen. Die Beispiel-Dienstfunktion (
my_echo_udf
) kann als Eingabe entweder eine einzelne Zeichenfolge oder eine Liste von Zeichenfolgen als Eingabe annehmen.Beispiel 1.1: Einzelne Zeichenfolge übergeben
Um die Dienstfunktion
my_echo_udf
aufzurufen, führen Sie die folgende SELECT-Anweisung aus und übergeben genau eine Eingabezeichenfolge ('hello'
):SELECT my_echo_udf('hello!');
Snowflake sendet eine POST-Anforderung an den Dienstendpunkt (
echoendpoint
). Nach Erhalt der Anforderung gibt der Dienst die Eingabezeichenfolge als Echo in der Antwort zurück.+--------------------------+ | **MY_ECHO_UDF('HELLO!')**| |------------------------- | | Bob said hello! | +--------------------------+
Beispiel 1.2: Liste von Zeichenfolge übergeben
Wenn Sie eine Liste von Zeichenfolgen an die Dienstfunktion übergeben, fasst Snowflake diese Eingabezeichenfolgen in einem Batch zusammen und sendet eine Serie von POST-Anforderungen an den Dienst. Nachdem der Dienst alle Zeichenfolgen verarbeitet hat, kombiniert Snowflake die Ergebnisse und gibt sie zurück.
Im folgenden Beispiel wird eine Tabellenspalte als Eingabe an die Dienstfunktion übergeben.
Erstellen Sie eine Tabelle mit mehreren Zeichenfolgen:
CREATE TABLE messages (message_text VARCHAR) AS (SELECT * FROM (VALUES ('Thank you'), ('Hello'), ('Hello World')));
Überprüfen Sie, ob die Tabelle erstellt wurde, indem Sie folgende Anweisung ausführen:
SELECT * FROM messages;
Um die Dienstfunktion aufzurufen, führen Sie die folgende SELECT-Anweisung aus und übergeben dabei Tabellenzeilen als Eingabe:
SELECT my_echo_udf(message_text) FROM messages;
Ausgabe:
+---------------------------+ | MY_ECHO_UDF(MESSAGE_TEXT) | |---------------------------| | Bob said Thank you | | Bob said Hello | | Bob said Hello World | +---------------------------+
Webbrowser verwenden: Der Dienst stellt den Endpunkt öffentlich zur Verfügung (siehe Inline-Spezifikation im Befehl CREATE SERVICE). Daher können Sie sich bei einer Web-UI anmelden, die der Dienst im Internet bereitstellt, und dann von einem Webbrowser aus Anforderungen an den Dienst senden.
Ermitteln Sie die URL des öffentlichen Endpunkts, den der Dienst bereitstellt:
SHOW ENDPOINTS IN SERVICE echo_service;
Die Spalte
ingress_url
in der Antwort enthält die URL.Beispiel
p6bye-myorg-myacct.snowflakecomputing.app
Hängen Sie
/ui
an die Endpunkt-URL an, und geben Sie diese Zeichenfolge in den Webbrowser ein. Dies veranlasst den Dienst, die Funktionui()
auszuführen (sieheecho_service.py
).Beachten Sie, dass Sie beim ersten Zugriff auf die Endpunkt-URL aufgefordert werden, sich bei Snowflake anzumelden. Verwenden Sie für diesen Test denselben Benutzer, mit dem Sie den Dienst erstellt haben, um sicherzustellen, dass der Benutzer über die erforderlichen Berechtigungen verfügt.
Geben Sie in das Feld Input die Zeichenfolge „Hello“ ein, und drücken Sie die Eingabetaste.
Bemerkung
Sie können auf den Eingangsendpunkt programmgesteuert zugreifen. Ein Beispielcode ist unter Zugriff auf öffentliche Endpunkte und Authentifizierung zu finden. Beachten Sie, dass Sie im Code an die Endpunkt-URL die Pfadangabe
/ui
anhängen müssen, damit Snowflake die Anfrage an dieui()
-Funktion im Dienstcode weiterleiten kann.
5: Bereinigen¶
Wenn Sie nicht vorhaben, mit Tutorial 2 oder Tutorial 3 fortzufahren, sollten Sie die von Ihnen erstellten abrechenbaren Ressourcen wieder entfernen. Weitere Informationen dazu finden Sie in Schritt 5 von Tutorial 3.
6: Erläuterungen zum Dienstcode¶
In diesem Abschnitt werden die folgenden Themen behandelt:
Code von Tutorial 1 überprüfen: Überprüfen Sie die Codedateien, die den Echo-Dienst implementieren.
Erläuterungen zur Dienstfunktion: In diesem Abschnitt wird erklärt, wie in diesem Tutorial die Dienstfunktion mit dem Dienst verknüpft ist.
Lokales Erstellen und Testen eines Images. In diesem Abschnitt wird erläutert, wie Sie das Docker-Image lokal testen können, bevor Sie es in ein Repository in Ihrem Snowflake-Konto hochladen.
Code von Tutorial 1 überprüfen¶
Die ZIP-Datei, die Sie in Schritt 1 heruntergeladen haben, enthält die folgenden Dateien:
Dockerfile
echo_service.py
templates/basic_ui.html
Beim Erstellen des Dienstes verwenden Sie außerdem Dienstspezifikationen. Im folgenden Abschnitt wird erläutert, wie diese Codekomponenten beim Erstellen des Dienstes zusammenwirken.
Datei „echo_service.py“¶
Diese Python-Datei enthält den Code, der einen minimalen HTTP-Server implementiert, der eingegebenen Text (als Echo) wieder zurückgibt. Der Code erfüllt in erster Linie zwei Aufgaben: die Bearbeitung von Echo-Anforderungen von Snowflake-Dienstfunktionen und die Bereitstellung einer Web-Benutzeroberfläche (UI) für die Übermittlung von Echo-Anforderungen.
from flask import Flask
from flask import request
from flask import make_response
from flask import render_template
import logging
import os
import sys
SERVICE_HOST = os.getenv('SERVER_HOST', '0.0.0.0')
SERVER_PORT = os.getenv('SERVER_PORT', 8080)
CHARACTER_NAME = os.getenv('CHARACTER_NAME', 'I')
def get_logger(logger_name):
logger = logging.getLogger(logger_name)
logger.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
handler.setLevel(logging.DEBUG)
handler.setFormatter(
logging.Formatter(
'%(name)s [%(asctime)s] [%(levelname)s] %(message)s'))
logger.addHandler(handler)
return logger
logger = get_logger('echo-service')
app = Flask(__name__)
@app.get("/healthcheck")
def readiness_probe():
return "I'm ready!"
@app.post("/echo")
def echo():
'''
Main handler for input data sent by Snowflake.
'''
message = request.json
logger.debug(f'Received request: {message}')
if message is None or not message['data']:
logger.info('Received empty message')
return {}
# input format:
# {"data": [
# [row_index, column_1_value, column_2_value, ...],
# ...
# ]}
input_rows = message['data']
logger.info(f'Received {len(input_rows)} rows')
# output format:
# {"data": [
# [row_index, column_1_value, column_2_value, ...}],
# ...
# ]}
output_rows = [[row[0], get_echo_response(row[1])] for row in input_rows]
logger.info(f'Produced {len(output_rows)} rows')
response = make_response({"data": output_rows})
response.headers['Content-type'] = 'application/json'
logger.debug(f'Sending response: {response.json}')
return response
@app.route("/ui", methods=["GET", "POST"])
def ui():
'''
Main handler for providing a web UI.
'''
if request.method == "POST":
# getting input in HTML form
input_text = request.form.get("input")
# display input and output
return render_template("basic_ui.html",
echo_input=input_text,
echo_reponse=get_echo_response(input_text))
return render_template("basic_ui.html")
def get_echo_response(input):
return f'{CHARACTER_NAME} said {input}'
if __name__ == '__main__':
app.run(host=SERVICE_HOST, port=SERVER_PORT)
Erläuterungen zum Code:
Die Funktion
echo
ermöglicht es einer Snowflake-Dienstfunktion, mit dem Dienst zu kommunizieren. Diese Funktion spezifiziert den Decorator@app.post()
wie gezeigt:@app.post("/echo") def echo():
Wenn der Echo-Server Ihre HTTP-POST-Anforderung mit dem
/echo
-Pfad erhält, leitet er die Anforderung an diese Funktion weiter. Die Funktion wird ausgeführt und gibt die Zeichenfolge aus dem Anforderungstext als Echo in der Antwort wieder zurück.Um Kommunikation einer Snowflake-Dienstfunktion zu unterstützen, implementiert dieser Server die externen Funktionen. Das heißt, die Serverimplementierung folgt einem bestimmten Eingabe-/Ausgabedatenformat, um als SQL-Funktion zu dienen, und dies ist das gleiche Eingabe-/Ausgabedatenformat, das von externen Funktionen verwendet wird.
Der Funktionsabschnitt
ui
des Codes zeigt ein Webformular an und verarbeitet die vom Webformular übermittelten Echo-Anforderungen. Diese Funktion verwendet den Decorator@app.route()
, um anzugeben, dass Anforderungen für/ui
von dieser Funktion bearbeitet werden:@app.route("/ui", methods=["GET", "POST"]) def ui():
Der Echo-Dienst stellt den Endpunkt
echoendpoint
öffentlich zur Verfügung (siehe Dienstspezifikation) und ermöglicht so die Kommunikation mit dem Dienst über das Web. Wenn Sie die URL des öffentlichen Endpunkts mit angehängtem „/ui“ in Ihrem Browser laden, sendet der Browser eine HTTP-GET-Anforderung für diesen Pfad, und der Server leitet die Anforderung an diese Funktion weiter. Die Funktion wird ausgeführt und gibt ein einfaches HTML-Formular zurück, in das der Benutzer eine Zeichenfolge eingeben kann.Nachdem der Benutzer eine Zeichenfolge eingegeben und das Formular übermittelt hat, sendet der Browser eine HTTP-Post-Anforderung für diesen Pfad, und der Server leitet die Anforderung an dieselbe Funktion weiter. Die Funktion wird ausgeführt und gibt eine HTTP-Antwort zurück, die die ursprüngliche Zeichenfolge enthält.
Die Funktion
readiness_probe
verwendet den Decorator@app.get()
, um zu spezifizieren, dass Anforderungen für/healthcheck
von dieser Funktion verarbeitet werden:@app.get("/healthcheck") def readiness_probe():
Mit dieser Funktion kann Snowflake die Bereitschaft des Dienstes überprüfen. Wenn der Container startet, möchte Snowflake bestätigen, dass die Anwendung funktioniert und der Dienst bereit ist, Anforderungen zu bedienen. Snowflake sendet eine HTTP-GET-Anforderung mit diesem Pfad, um auf Funktionsfähigkeit (Health Probe) und Bereitschaft (Readiness Probe) zu testen und somit sicherzustellen, dass nur funktionsfähige Container den Datenverkehr bedienen. Die Funktion kann alles tun, was Sie möchten.
Die Funktion
get_logger
hilft beim Einrichten der Protokollierung.
Datei „Dockerfile“¶
Diese Datei enthält alle Befehle, um ein Image mit Docker zu erstellen.
ARG BASE_IMAGE=python:3.10-slim-buster
FROM $BASE_IMAGE
COPY echo_service.py ./
COPY templates/ ./templates/
RUN pip install --upgrade pip && \\
pip install flask
CMD ["python", "echo_service.py"]
„Dockerfile“ enthält Anweisungen zur Installation der Flask-Bibliothek im Docker-Container. Der Code in echo_service.py
stützt sich auf die Flask-Bibliothek, um HTTP-Anforderungen zu verarbeiten.
Datei „/template/basic_ui.html“¶
Der Echo-Dienst stellt den Endpunkt echoendpoint
öffentlich zur Verfügung (siehe Dienstspezifikation) und ermöglicht so die Kommunikation mit dem Dienst über das Web. Wenn Sie die URL des öffentlichen Endpunkts mit angehängtem /ui
in Ihrem Browser laden, zeigt der Echo-Dienst dieses Formular an. Sie können eine Zeichenfolge in das Formular eingeben und das Formular absenden, und der Dienst gibt die Zeichenfolge in einer HTTP-Antwort zurück.
<!DOCTYPE html>
<html lang="en">
<head>
<title>Welcome to echo service!</title>
</head>
<body>
<h1>Welcome to echo service!</h1>
<form action="{{ url_for("ui") }}" method="post">
<label for="input">Input:<label><br>
<input type="text" id="input" name="input"><br>
</form>
<h2>Input:</h2>
{{ echo_input }}
<h2>Output:</h2>
{{ echo_reponse }}
</body>
</html>
Dienstspezifikation¶
Snowflake verwendet die von Ihnen in dieser Spezifikation angegebenen Informationen zur Konfiguration und Ausführung Ihres Dienstes.
spec:
containers:
- name: echo
image: /tutorial_db/data_schema/tutorial_repository/my_echo_service_image:latest
env:
SERVER_PORT: 8000
CHARACTER_NAME: Bob
readinessProbe:
port: 8000
path: /healthcheck
endpoints:
- name: echoendpoint
port: 8000
public: true
Erläuterungen zur Dienstspezifikation:
containers.image
gibt das Image an, mit dem Snowflake einen Container startet.Das optionale Feld
endpoints
gibt den Endpunkt an, den der Dienst öffentlich bereitstellt.name
gibt einen benutzerfreundlichen Namen für den TCP-Netzwerkport an, den der Container auf Anforderungen überwacht. Sie verwenden diesen benutzerfreundlichen Endpunktnamen, um Anforderung an den entsprechenden Port zu senden. Beachten Sie, dass diese Portnummer überenv.SERVER_PORT
gesteuert wird.Der Endpunkt ist ebenfalls als
public
konfiguriert. Dies ermöglicht Datenverkehr zu diesem Endpunkt aus dem öffentlichen Web.
Das optionale Feld
containers.env
wurde hinzugefügt, um zu veranschaulichen, wie Sie Umgebungsvariablen überschreiben können, die Snowflake an alle Prozesse in Ihrem Container übergibt. Der Dienstcode inecho_service.py
liest beispielsweise die Umgebungsvariablen mit Standardwerten wie gezeigt:CHARACTER_NAME = os.getenv('CHARACTER_NAME', 'I') SERVER_PORT = os.getenv('SERVER_PORT', 8080)
Dies funktioniert wie folgt:
Wenn der Echo-Dienst eine HTTP-POST-Anforderung mit einer Zeichenfolge (z. B. „Hallo“) im Anforderungstext erhält, gibt der Dienst standardmäßig „I said Hello“ (Ich sagte Hallo) zurück. Der Code verwendet die Umgebungsvariable
CHARACTER_NAME
, um das Wort vor „said“ (sagte) zu bestimmen. Standardmäßig istCHARACTER_NAME
auf „I“ (Ich) eingestellt.Sie können den Standardwert von CHARACTER_NAME in der Dienstspezifikation überschreiben. Wenn Sie den Wert beispielsweise auf „Bob“ setzen, gibt der Echo-Dienst die Antwort „Bob said Hello“ (Bob sagte Hallo) zurück.
In ähnlicher Weise überschreibt die Dienstspezifikation den Port (SERVER_PORT), den der Dienst überwacht, mit 8000, wodurch der Standardport 8080 außer Kraft gesetzt wird.
Das Feld
readinessProbe
identifiziert die Werte vonport
undpath
, mit denen Snowflake eine HTTP-GET-Anforderung an den Bereitschaftstest (Readiness Probe) senden kann, um zu überprüfen, ob der Dienst bereit ist, Datenverkehr zu verarbeiten.Mit dem Dienstcode in
echo_python.py
wird der Bereitschaftstest wie folgt implementiert:@app.get("/healthcheck") def readiness_probe():
Daher enthält die Spezifikationsdatei das entsprechende Feld
container.readinessProbe
.
Weitere Informationen zu Dienstspezifikationen finden Sie unter Referenz der Dienstspezifikation.
Erläuterungen zur Dienstfunktion¶
Eine Dienstfunktion ist eine der Methoden, um mit Ihrem Dienst zu kommunizieren (siehe Verwenden eines Dienstes). Eine Dienstfunktion ist eine benutzerdefinierte Funktion (UDF), die Sie mit einem Dienstendpunkt verknüpfen. Wenn die Dienstfunktion ausgeführt wird, sendet sie eine Anforderung an den zugehörigen Dienstendpunkt und empfängt eine Antwort.
Sie erstellen die folgende Dienstfunktion, indem Sie den Befehl CREATE FUNCTION mit den folgenden Parametern ausführen:
CREATE FUNCTION my_echo_udf (InputText VARCHAR)
RETURNS VARCHAR
SERVICE=echo_service
ENDPOINT=echoendpoint
AS '/echo';
Beachten Sie Folgendes:
Die Funktion
my_echo_udf
nimmt eine Zeichenfolge als Eingabe entgegen und gibt eine Zeichenfolge zurück.Die Eigenschaft SERVICE bezeichnet den Dienst (
echo_service
), und die Eigenschaft ENDPOINT bezeichnet den benutzerfreundlichen Namen des Endpunkts (echoendpoint
).„AS ‚/echo‘“ gibt den Pfad für den Dienst an. In
echo_service.py
verknüpft der Decorator@app.post
diesen Pfad mit derecho
-Funktion.
Diese Funktion stellt eine Verbindung mit dem spezifischen Endpunkt in ENDPOINT des in SERVICE angegebenen Dienstes her. Wenn Sie diese Funktion aufrufen, sendet Snowflake eine Anforderung an den Pfad /echo
innerhalb des Dienstcontainers.
Lokales Erstellen und Testen eines Images¶
Sie können das Docker-Image lokal testen, bevor Sie es in ein Repository Ihres Snowflake-Kontos hochladen. Bei lokalen Tests wird Ihr Container eigenständig ausgeführt (er ist kein Dienst, der von Snowflake ausgeführt wird).
So testen Sie das Docker-Image von Tutorial 1:
Um ein Docker-Image zu erstellen, führen Sie über die Docker-CLI den folgenden Befehl aus:
docker build --rm -t my_service:local .
Um Ihren Code zu starten, führen Sie den folgenden Befehl aus:
docker run --rm -p 8080:8080 my_service:local
Senden Sie eine Echo-Anforderung an den Dienst mit einer der folgenden Methoden:
Verwenden des cURL-Befehls:
Senden Sie in einem anderen Terminalfenster mit cURL die folgende POST-Anforderung an Port 8080:
curl -X POST http://localhost:8080/echo \ -H "Content-Type: application/json" \ -d '{"data":[[0, "Hello friend"], [1, "Hello World"]]}'
Beachten Sie, dass der Anforderungstext zwei Zeichenfolgen enthält. Dieser cURL-Befehl sendet eine POST-Anforderung an Port 8080, der vom Dienst auf Anforderungen überwacht wird. Die 0 in den Daten ist der Index der Eingabezeichenfolge in der Liste. Der Echo-Dienst gibt die Eingabezeichenfolgen als Echo wie folgt zurück:
{"data":[[0,"I said Hello Friend"],[1,"I said Hello World"]]}
Verwenden eines Webbrowsers:
Öffnen Sie in Ihrem Browser auf demselben Computer
http://localhost:8080/ui
.Dadurch wird eine GET-Anforderung an Port 8080 gesendet, der vom Dienst auf Anforderungen überwacht wird. Der Dienst führt die Funktion
ui()
aus, die wie gezeigt ein HTML-Formular ausgibt:Geben Sie in das Feld Input die Zeichenfolge „Hello“ ein, und drücken Sie die Eingabetaste.
Nächste Schritte¶
Sie können nun mit Tutorial 2 fortfahren, in dem ein Job ausgeführt wird.