Tutorial 3: Snowpark Container Services erstellen und verwalten¶

Einführung¶

Snowpark Container Services ist ein vollständig verwaltetes Container-Angebot, das die Bereitstellung, Verwaltung und Skalierung von containerisierten Anwendungen innerhalb des Snowflake-Ökosystems vereinfacht. Mit diesem Feature können Sie containerisierte Workloads direkt in Snowflake ausführen.

In diesem Tutorial lernen Sie, wie Sie mit Snowflake Python APIs Komponenten in Snowpark Container Services verwalten können.

Einrichten Ihrer Entwicklungsumgebung¶

Wenn Sie für die vorherigen Tutorials von Snowflake Python APIs ein Notebook verwendet haben, wechseln Sie in diesem Tutorial zu einem neuen Notebook. Das Notebook enthält einen Beispielcode, der einen NGINX-Webserver unter Verwendung von Snowpark Container Services ausführt, der komplett in Snowflake läuft.

1. Öffnen Sie ein neues Notizbuch mit Ihrem bevorzugten Code-Editor oder indem Sie den jupyter notebook-Befehl ausführen.

2. Führen Sie in der ersten Zelle Ihres Notizbuchs den folgenden Code aus:

   from snowflake.core.database import Database
   from snowflake.core.schema import Schema
   
   database = root.databases.create(Database(name="spcs_python_api_db"), mode="orreplace")
   schema = database.schemas.create(Schema(name="public"), mode="orreplace")
   

   Copy

   Mit der Verbindung zu Snowflake und dem Objekt root, das Sie zuvor in der gemeinsamen Einrichtung erstellt haben, erstellen Sie eine Datenbank namens spcs_python_api_db und ein Schema namens public in dieser Datenbank. Sie speichern auch Referenzen, die diese neu erstellten Objekte repräsentieren. Ihre Snowpark Container Services-Komponenten werden in dieser Datenbank und diesem Schema leben.

Überblick über Snowpark Container Services¶

Bevor Sie mit dem Tutorial fortfahren, sollten Sie sich kurz die Hauptkomponenten von Snowpark Container Services ansehen. Um containerisierte Anwendungen in Snowpark Container Services auszuführen, arbeiten Sie normalerweise mit den folgenden Objekten:

• Image-Repository: Bietet eine Speichereinheit, in der Sie Ihre Anwendungs-Images in Ihr Snowflake Konto hochladen können.

  Snowpark Container Services bietet einen OCIv2-kompatiblen Image Registry Service, der es OCI-Clients (wie Docker CLI und SnowSQL) ermöglicht, auf eine Image Registry in Ihrem Snowflake-Konto zuzugreifen. Mit diesen Clients können Sie Ihre Anwendungs-Images in ein Repository hochladen.

  Weitere Informationen dazu finden Sie unter Verwenden von Image-Registry und Image-Repository.

• Computepool: Repräsentiert eine Gruppe von Computerressourcen (Knoten virtueller Maschinen).

  Diese Computerressourcen sind mit den virtuellen Warehouses von Snowflake vergleichbar, aber nicht gleichwertig. Der Dienst (in diesem Fall Ihr NGINX-Dienst) wird im Computepool ausgeführt. Rechenintensive Dienste erfordern leistungsstarke Computepools mit vielen Kernen und vielen GPUs, während weniger intensive Dienste in kleineren Computepools mit weniger Kernen laufen können.

  Weitere Informationen dazu finden Sie unter Verwenden von Computepools.

• Service: Bietet eine Möglichkeit, einen Anwendungscontainer auszuführen.

  Für Services sind mindestens eine Spezifikation und ein Computepool erforderlich. Eine Spezifikation enthält die Informationen, die für die Ausführung des Anwendungscontainers benötigt werden, z. B. den Pfad zu einem Container-Image und die Endpunkte, die die Dienste bereitstellen. Die Spezifikation ist in YAML verfasst. Der Computepool ist die Menge der Computerressourcen, in denen der Dienst ausgeführt wird.

  Weitere Informationen dazu finden Sie unter Verwenden von Diensten.

Fahren Sie mit den nächsten Schritten fort, um diese Objekte zu erstellen und festzulegen.

Image-Repository erstellen¶

In diesem Abschnitt erstellen Sie zunächst ein Image-Repository mit Hilfe des Snowflake Python APIs. Dann holen Sie ein NGINX-Anwendungsimage von Docker Hub und laden das Image mit Hilfe von Docker-CLI in das Image Repository hoch.

Erstellen eines Repositorys und Abrufen von Informationen über das Repository

1. Führen Sie in der nächsten Zelle Ihres Notebooks den folgenden Code aus:

   from snowflake.core.image_repository import ImageRepository
   
   my_repo = ImageRepository("MyImageRepository")
   schema.image_repositories.create(my_repo)
   

   Copy

   In diesem Codebeispiel erstellen Sie ein Image-Repository in der Datenbank und dem Schema, die Sie zuvor in diesem Tutorial erstellt haben.

2. Um zu bestätigen, dass das Repository erfolgreich erstellt wurde, indem Sie seine Details abrufen und seinen Namen ausgeben, führen Sie den folgenden Code aus:

   my_repo_res = schema.image_repositories["MyImageRepository"]
   my_repo = my_repo_res.fetch()
   print(my_repo.name)
   

   Copy

3. Sie benötigen Informationen über das Repository (das Repository-URL und den Hostnamen der Registry), bevor Sie das Image hochladen können.

   Um das Repository-URL zu erhalten, führen Sie in der nächsten Zelle den folgenden Code aus:

   repositories = schema.image_repositories
     for repo_obj in repositories.iter():
       print(repo_obj.repository_url)
   

   Copy

   • Das repository_url-Attribut in der Ausgabe liefert die URL. Beispiel:

     <orgname>-<acctname>.registry.snowflakecomputing.com/spcs_python_api_db/public/myimagerepository
     

   • Der Hostname im Repository-URL ist der Hostname der Registrierung. Beispiel:

     <orgname>-<acctname>.registry.snowflakecomputing.com
     

Rufen Sie das NGINX-Image ab und laden es in das Repository hoch

1. Damit Docker in Ihrem Namen ein Image in Ihr Repository hochladen kann, müssen Sie Docker zunächst mit Snowflake authentifizieren.

   Um Docker mit der Snowflake-Registrierung zu authentifizieren, öffnen Sie ein Terminal in der Befehlszeile und führen Sie den folgenden docker login-Befehl unter Verwendung des Docker-CLI aus:

   docker login <registry_hostname> -u <username>
   

   Copy

   • registry_hostname: Geben Sie den Hostnamen in repository_url aus dem Ergebnis des vorherigen Schritts an.

   • username: Geben Sie Ihren Snowflake-Benutzernamen an. Docker fordert Sie zur Eingabe Ihres Kennworts auf.

   Beispiel

   docker login myorg-myacct.registry.snowflakecomputing.com -u admin
   

   Copy

2. Rufen Sie den AMD64-Build des NGINX Images von Docker Hub: ab

   docker pull --platform linux/amd64 amd64/nginx
   

   Copy

3. Markieren Sie das amd64/nginx-Image mit dem Snowflake-Image-Repository-URL:

   docker tag docker.io/amd64/nginx:latest <repository_url>/<image_name>
   

   Copy

   Beispiel

   docker tag docker.io/amd64/nginx:latest myorg-myacct.registry.snowflakecomputing.com/spcs_python_api_db/public/myimagerepository/amd64/nginx:latest
   

   Copy

   Ein Tag ist ein benutzerdefinierter, von Menschen lesbarer Bezeichner, den Sie optional verwenden können, um eine bestimmte Version oder Variante eines Images zu identifizieren.

4. Laden Sie das Image in das Repository in Ihrem Snowflake-Konto hoch.

   docker push <repository_url>/<image_name>
   

   Copy

   Beispiel

   docker push myorg-myacct.registry.snowflakecomputing.com/spcs_python_api_db/public/myimagerepository/amd64/nginx:latest
   

   Copy

Einen Computepool erstellen¶

Um einen Computepool zu definieren und zu erstellen, führen Sie in der nächsten Zelle Ihres Notebooks den folgenden Code aus:

new_compute_pool_def = ComputePool(
    name="MyComputePool",
    instance_family="CPU_X64_XS",
    min_nodes=1,
    max_nodes=2,
)

new_compute_pool = root.compute_pools.create(new_compute_pool_def)

In dieser Zelle definieren Sie einen Computepool mit Hilfe des ComputePool Konstruktors, indem Sie Werte für die folgenden Attribute angeben:

• instance_family: Die Instanzfamilie bezeichnet den Typ des Rechners, den Sie für die Knoten im Computepool bereitstellen möchten.

  Jeder Maschinentyp stellt eine unterschiedliche Menge an Computerressourcen für seine Computepools zur Verfügung. In dieser Zelle verwenden Sie den kleinsten verfügbaren Maschinentyp, CPU_X64_XS. Weitere Informationen dazu finden Sie unter CREATE COMPUTE POOL.

• min_nodes: Die Mindestanzahl von Knoten, mit denen der Computepool gestartet wird.

• max_nodes: Die maximale Anzahl von Knoten, auf die der Computepool skaliert werden kann.

  Wenn Sie einen Computepool erstellen, startet Snowflake ihn mit der angegebenen Mindestanzahl von Knoten. Snowflake verwaltet dann die Skalierung automatisch und erstellt neue Knoten - bis zu der angegebenen Höchstzahl -, wenn die laufenden Knoten keine zusätzliche Arbeitslast mehr aufnehmen können.

Dann erstellen Sie den Computepool, indem Sie die Definition des Computepools an compute_pools.create() übergeben.

Dienst erstellen¶

Unter Verwendung des von Ihnen eingerichteten Image-Repositorys und Computepools können Sie nun Ihren Dienst definieren und erstellen. Ein Dienst bezieht sich auf eine Sammlung von Containern, die in einem Computepool laufen und die alle in Snowflake orchestriert werden.

1. Um das Repository mit Ihrem Container-Image abzurufen, führen Sie in der nächsten Zelle Ihres Notebooks den folgenden Code aus:

   image_repository = schema.image_repositories["MyImageRepository"]
   

   Copy

   Dieses Repository befindet sich in Ihrem Snowflake-Konto und ist als Stagingbereich im PUBLIC-Schema aufgelistet. Sie benötigen diese Referenz, um im nächsten Schritt die Informationen zum Container-Image abzurufen.

2. Um Ihren Dienst zu definieren und zu erstellen, führen Sie in Ihrer nächsten Zelle den folgenden Code aus:

   from textwrap import dedent
   from io import BytesIO
   from snowflake.core.service import Service, ServiceSpecInlineText
   
   specification = dedent(f"""\
       spec:
         containers:
         - name: web-server
           image: {image_repository.fetch().repository_url}/amd64/nginx:latest
         endpoints:
         - name: ui
           port: 80
           public: true
       """)
   
   service_def = Service(
       name="MyService",
       compute_pool="MyComputePool",
       spec=ServiceSpecInlineText(specification),
       min_instances=1,
       max_instances=1,
   )
   
   nginx_service = schema.services.create(service_def)
   

   Copy

   Diese Zelle definiert die Dienstspezifikation und den Dienst und erstellt dann den Dienst für Ihren NGINX-Webserver. Die Definitionen für die Spezifikation und den Dienst haben die folgenden Eigenschaften:

   • specification - Sie definieren die Spezifikation mit einer Python formatierten Zeichenfolge Literal (f-string). Die Zeichenfolge hat das Format YAML.

     Die Spezifikation enthält den Namen des Containers, einen Pfad zum Container-Image und die Endpunkte, die der Dienst für den öffentlichen Zugriff bereitstellen wird. In diesem Beispiel definieren Sie die Inline-Spezifikation, aber Sie können eine Spezifikation auch als Verweis auf eine .yml-Datei in einem Stagingbereich definieren.

   • service_def - Sie definieren einen Dienst mit dem Service Konstruktor, indem Sie einen Namen für den Dienst, den Computepool, in dem er laufen soll, einen Pfad zur Spezifikation und die Gesamtzahl der Instanzen für den Dienst angeben.

     In dieser Zelle verwenden Sie ServiceSpecInlineText, um den Wert von spec einzustellen, weil Sie die inline-Spezifikation als f-Zeichenfolge definieren. Sie können den Dienst für die Ausführung mehrerer Instanzen festlegen, aber in diesem Beispiel legen Sie nur eine Instanz des Dienstes fest, indem Sie min_instances und max_instances auf 1 einstellen.

3. Um den Status des Diensts zu überprüfen, führen Sie in Ihrer nächsten Zelle den folgenden Code aus:

   from pprint import pprint
   
   pprint(nginx_service.get_service_status(timeout=5))
   

   Copy

   Die Ausgabe sollte in etwa so aussehen:

   {'auto_resume': True,
   'auto_suspend_secs': 3600,
   'instance_family': 'CPU_X64_XS',
   'max_nodes': 1,
   'min_nodes': 1,
   'name': 'MyService'}
   

Nutzen Sie Ihren Dienst¶

Nachdem Sie den Dienst erstellt haben, benötigt Snowpark Container Services einige Minuten, um die Endpunkte bereitzustellen, die für den Zugriff auf den Dienst benötigt werden.

1. Um den Status der Endpunkte zu überprüfen, führen Sie in der nächsten Zelle Ihres Notebooks den folgenden Code aus:

   import json, time
   
   while True:
       public_endpoints = nginx_service.fetch().public_endpoints
       try:
           endpoints = json.loads(public_endpoints)
       except json.JSONDecodeError:
           print(public_endpoints)
           time.sleep(15)
       else:
           break
   

   Copy

   Das Codebeispiel ist nicht spezifisch für Snowpark Container Services oder Snowflake Python APIs - es bietet lediglich eine praktische Möglichkeit, um zu überprüfen, ob die Endpunkte bereit sind. Beachten Sie, dass Sie die Endpunkte abrufen, indem Sie .fetch().public_endpoints für Ihr Dienstobjekt aufrufen.

   Die Ausgabe sollte in etwa so aussehen:

   Endpoints provisioning in progress... check back in a few minutes
   Endpoints provisioning in progress... check back in a few minutes
   Endpoints provisioning in progress... check back in a few minutes
   

2. Nachdem die Endpunkte bereitgestellt wurden, können Sie die öffentlichen Endpunkte in Ihrem Browser öffnen.

   Führen Sie in Ihrer nächsten Zelle den folgenden Code aus:

   import webbrowser
   
   print(f"Visiting {endpoints['ui']} in your browser. You might need to log in there.")
   webbrowser.open(f"https://{endpoints['ui']}")
   

   Copy

   Die Ausgabe sollte in etwa so aussehen:

   Visiting myorg-myacct.snowflakecomputing.app in your browser. You might need to log in there.
   

   Bei Erfolg sehen Sie beim Besuch des Endpunkts in Ihrem Browser die folgende NGINX-Erfolgsseite:

   

3. Zur Verwaltung Ihres neuen Dienstes können Sie Python-API verwenden.

   Um beispielsweise den Dienst auszusetzen und dann seinen Status zu überprüfen, führen Sie den folgenden Code aus:

   from time import sleep
   
   nginx_service.suspend()
   sleep(3)
   print(nginx_service.get_service_status(timeout=5))
   

   Copy

4. Um den Dienst wieder aufzunehmen, führen Sie den folgenden Code aus:

   nginx_service.resume()
   sleep(3)
   print(nginx_service.get_service_status(timeout=5))
   

   Copy

Mit nur wenigen Zeilen Python konnten Sie einen NGINX-Webserver in Snowflake mit Snowpark Container Services betreiben.

Bereinigen¶

Snowflake erhebt Gebühren für aktive Computepoolknoten in Ihrem Konto. Um ungewollte Kosten zu vermeiden, setzen Sie zunächst den Dienst und den Computepool aus und löschen dann beide Objekte.

1. Um den Computepool und den Dienst auszusetzen, führen Sie in der nächsten Zelle Ihres Notebooks den folgenden Code aus:

   new_compute_pool_def.suspend()
   nginx_service.suspend()
   

   Copy

2. Um den Computepool und den Dienst zu beenden, führen Sie den folgenden Code aus:

   new_compute_pool_def.drop()
   nginx_service.drop()
   

   Copy

Nächste Schritte¶

Herzlichen Glückwunsch! In diesem Tutorial haben Sie die Grundlagen für das Management von Komponenten in Snowpark Container Services mit Hilfe der Snowflake Python APIs kennengelernt.