Weaviate ist eine bahnbrechende Open-Source-Vektordatenbank, die die semantische Suche durch die Nutzung von Modellen des maschinellen Lernens verbessern soll. Im Gegensatz zu herkömmlichen Suchmaschinen, die auf Keyword-Matching basieren, verwendet Weaviate Prinzipien der semantischen Ähnlichkeit. Dieser innovative Ansatz wandelt verschiedene Datenformen (Texte, Bilder und mehr) in Vektordarstellungen um, also numerische Formen, die das Wesentliche des Kontexts und der Bedeutung der Daten erfassen. Durch die Analyse der Ähnlichkeiten zwischen diesen Vektoren liefert Weaviate Suchergebnisse, die die Absicht des Benutzers wirklich verstehen, und bietet damit einen deutlichen Sprung über die Einschränkungen schlüsselwortbasierter Suchen hinaus.

Dieser Leitfaden soll die nahtlose Integration von MinIO und Weaviate demonstrieren und dabei das Beste aus Kubernetes-nativem Objektspeicher und KI-gestützten semantischen Suchfunktionen nutzen. Dieser Leitfaden nutzt Docker Compose für die Container-Orchestrierung und bietet einen strategischen Ansatz zum Aufbau eines robusten, skalierbaren und effizienten Datenverwaltungssystems. Dieses Setup ist auf die Art und Weise ausgerichtet, wie wir Daten speichern, darauf zugreifen und sie verwalten, und ist ein Wendepunkt für Entwickler, DevOps-Ingenieure und Datenwissenschaftler, die die Leistung moderner Speicherlösungen und KI-gesteuerten Datenabrufs nutzen möchten.

Einführung in den Tech Stack

In dieser Demonstration konzentrieren wir uns auf die Sicherung von Weaviate mit MinIO-Buckets unter Verwendung von Docker. Dieses Setup gewährleistet Datenintegrität und -zugänglichkeit in unseren KI-gestützten Such- und Analyseprojekten.

• MinIO für Speicher : Wir verwenden MinIO als unsere primäre Speicherplattform. MinIO ist für seine hohe Leistung und Skalierbarkeit bekannt und kann große Datenmengen sicher und effizient verarbeiten. In dieser Demo sehen Sie, wie MinIO-Buckets zum Sichern von Weaviate-Daten verwendet werden, um sicherzustellen, dass die Integrität und Leistung unseres Systems nicht beeinträchtigt werden.

  
  

• Weaviate-Vektordatenbank : Die Vektordatenbank von Weaviate ist ein zentraler Bestandteil dieser Integration und ermöglicht KI-Anwendungen die Durchführung semantischer Suchvorgänge. Durch die Umwandlung unstrukturierter Daten in aussagekräftige Vektordarstellungen können Anwendungen Daten auf sehr differenzierte Weise verstehen und mit ihnen interagieren. Dies ebnet den Weg für intelligentere und reaktionsschnellere KI-gesteuerte Funktionen.

  
  

Diese Demonstration soll die nahtlose Integration von MinIO und Weaviate mithilfe von Docker hervorheben und eine zuverlässige Methode zum Sichern von KI-gestützten Such- und Analysesystemen präsentieren.

Ressourcen

• Alle Dateien sind über GitHub verfügbar minio/blog-assets/minio-weaviate-backups Repository-Ordner.
• docker-compose.yaml
• schema.json
• Daten.json
• s3_backup_module.ipynb

Sachkundige Voraussetzungen

• Docker und Docker Compose sind auf Ihrem Computer installiert.
• Grundlegendes Verständnis von Docker-Konzepten und YAML-Syntax.
• Python-Umgebung zur Verwendung der Weaviate-Client-Bibliothek.
• Befehlszeilenzugriff zum Ausführen von Befehlen wie curl.

Integration und Konfiguration mit Docker Compose

Die hier bereitgestellte Datei docker-compose.yaml wurde entwickelt, um eine nahtlose Einrichtung für Weaviate zu ermöglichen und unser Engagement für eine optimierte und effiziente Datenverwaltung zu unterstreichen. Diese Konfiguration ermöglicht eine robuste Umgebung, in der MinIO als sicherer Speicherdienst fungiert und Weaviate diesen Speicher für erweiterte Vektorsuchfunktionen nutzt.

Der docker-compose.yaml Im Folgenden wird die Einrichtung für Weaviate beschrieben.

 version: '3.8' services: weaviate: container_name: weaviate_server image: semitechnologies/weaviate:latest ports: - "8080:8080" environment: AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED: 'true' PERSISTENCE_DATA_PATH: '/var/lib/weaviate' ENABLE_MODULES: 'backup-s3' BACKUP_S3_BUCKET: 'weaviate-backups' BACKUP_S3_ENDPOINT: 'play.min.io:443' BACKUP_S3_ACCESS_KEY_ID: 'minioadmin' BACKUP_S3_SECRET_ACCESS_KEY: 'minioadmin' BACKUP_S3_USE_SSL: 'true' CLUSTER_HOSTNAME: 'node1' volumes: - ./weaviate/data:/var/lib/weaviate

Docker-Compose: Weaviate mit aktiviertem backups-s3 Modul und MinIO-Server play.min.io bereitstellen

Konfigurieren von Weaviate für S3-Backup

Mit dem obigen docker-compose.yaml ist Weaviate so konfiguriert, dass es MinIO für Backups verwendet und so Datenintegrität und -zugänglichkeit gewährleistet. Dieses Setup umfasst wichtige Umgebungsvariablen wie ENABLE_MODULES , die auf backup-s3 gesetzt sind, und verschiedene Einstellungen für den S3-Bucket, den Endpunkt, die Zugriffsschlüssel und die SSL-Nutzung. Darüber hinaus wird PERSISTENCE_DATA_PATH gesetzt, um sicherzustellen, dass Daten dauerhaft gespeichert werden, und CLUSTER_NAME dient zur Knotenidentifikation.

Wichtige Umgebungsvariablen sind :

• ENABLE_MODULES : "Backup-S3"
• BACKUP_S3_BUCKET : "weaviate-backups"
• BACKUP_S3_ENDPOINT : "play.min.io:443"
• BACKUP_S3_ACCESS_KEY_ID : "minioadmin"
• BACKUP_S3_SECRET_ACCESS_KEY : "minioadmin"
• BACKUP_S3_USE_SSL : "wahr"
• PERSISTENCE_DATA_PATH : „/var/lib/weaviate“
• CLUSTER_NAME : "Knoten1"

Der Weaviate-Dienst in dieser Docker-Zusammenstellung ist so eingerichtet, dass er gemountete Volumes zur Datenpersistenz nutzt. Dadurch wird sichergestellt, dass Ihre Daten über Sitzungen und Vorgänge hinweg bestehen bleiben.

Bereitstellungsschritte

Um MinIO und Weaviate mithilfe von Docker Compose in Ihr Projekt zu integrieren, befolgen Sie diese detaillierte Vorgehensweise:

Speichern oder Aktualisieren der Docker Compose-Datei

• Neues Setup : Wenn dies ein neues Setup ist, speichern Sie die bereitgestellte Datei docker-compose.yaml direkt im Arbeitsverzeichnis Ihres Projekts. Diese Datei ist für die korrekte Konfiguration der Dienste von entscheidender Bedeutung.

  
  

• Vorhandenes Setup : Wenn Sie eine vorhandene Produktionsumgebung aktualisieren, ändern Sie Ihre aktuelle Datei docker-compose.yaml, um die oben beschriebenen Einstellungen widerzuspiegeln. Stellen Sie sicher, dass diese Einstellungen für die Verbindung mit Ihren Diensten genau repliziert werden.

Ausführen der Docker Compose-Datei

Sobald die Datei docker-compose.yaml vorhanden ist, verwenden Sie den folgenden Befehl in Ihrem Terminal oder Ihrer Eingabeaufforderung, um die Bereitstellung zu starten:

docker-compose up -d --build

Dieser Befehl startet die Weaviate-Dienste im getrennten Modus und führt sie im Hintergrund Ihres Systems aus.

Persistente Verzeichnisse verstehen

• Während des Erstellungs- und Ausführungsprozesses erstellt Docker Compose ein persistentes Verzeichnis, wie in der Datei docker-compose.yaml angegeben. Dieses Verzeichnis ( ./weaviate/data für Weaviate) wird zum persistenten Speichern von Daten verwendet und stellt sicher, dass Ihre Daten bei Neustarts und Bereitstellungen des Containers intakt bleiben.

  
  

Der dauerhafte Speicher ermöglicht eine stabilere Umgebung, in der beim Neustart des Containers keine Daten verloren gehen.

Sobald Sie Ihr Docker-Compose bereitgestellt haben, können Sie die URL Ihres Weaviate-Servers in einem Browser aufrufen und anschließend /v1/meta eingeben, um zu überprüfen, ob Ihre Bereitstellungskonfigurationen korrekt sind.

Die erste Zeile der JSON-Nutzlast unter http://localhost:8080/v1/meta sollte folgendermaßen aussehen:

 {"hostname":"http://[::]:8080","modules":{"backup-s3":{"bucketName":"weaviate-backups","endpoint":"play.min.io:443","useSSL":true}...[truncated]...}

MinIO konfigurieren: Zugriffsrichtlinie für weaviate-backups Bucket

Um Weaviate in MinIO zu integrieren, muss der Backup-Bucket in MinIO die Zugriffsrichtlinie des angegebenen Backup-Buckets, nämlich weaviate-backups , auf „Öffentlich“ setzen. Diese Anpassung ist erforderlich, um dem Weaviate-Modul „backup-s3“ die erforderlichen Berechtigungen für die erfolgreiche Interaktion mit dem MinIO-Bucket für Sicherungsvorgänge zu erteilen.

Es ist wichtig, sich bei dieser Konfiguration über die Sicherheitsauswirkungen im Klaren zu sein, die sich ergeben, wenn ein Bucket auf „ öffentlich “ gesetzt wird. Während diese Konfiguration den Backup-Prozess in einer Entwicklungsumgebung erleichtert, sollten für Produktionssysteme alternative Ansätze in Betracht gezogen werden, um die Datensicherheit und -integrität aufrechtzuerhalten. Verwenden Sie feinkörnige Zugriffskontrollen, wie z. B. IAM-Richtlinien oder „ vorsignierte “ URLs.

Am Ende dieser Demonstration können Sie die Bucket-Objekte sehen, die Weaviate während des gesamten Prozesses erstellt, wenn das Modul backup-s3 verwendet wird.

Skizzieren des Prozesses mit Python

Um S3-Backups in Weaviate zu aktivieren, legen Sie die erforderlichen Umgebungsvariablen in Ihrer Datei docker-compose.yaml fest. Dadurch wird Weaviate angewiesen, MinIO als Backup-Ziel zu verwenden, einschließlich Einstellungen für Backup-Module und MinIO-Bucket-Details.

Bevor ich mich in die technischen Vorgänge vertiefe, möchte ich darauf hinweisen, dass ich die folgenden Schritte in einer JupyterLab-Umgebung demonstriere, um den zusätzlichen Vorteil der Kapselung unserer Pipeline in einem Notebook zu erzielen, das hier verfügbar ist.

Der erste Schritt umfasst das Einrichten der Umgebung durch die Installation der weaviate-client Bibliothek für Python mit pip . Dieses Python-Paket ist für die Schnittstelle mit der RESTful-API von Weaviate auf eine pythonartigere Weise unerlässlich und ermöglicht eine nahtlose Interaktion mit der Datenbank für Vorgänge wie Schemaerstellung, Datenindizierung, Sicherung und Wiederherstellung. Zur Demonstration verwenden wir die Weaviate-Python-Client-Bibliothek.

In dieser Demonstration verwenden wir die Weaviate V3 API, daher wird beim Ausführen des Python-Skripts möglicherweise eine Meldung wie die folgende angezeigt:

 `DeprecationWarning: Dep016: You are using the Weaviate v3 client, which is deprecated. Consider upgrading to the new and improved v4 client instead! See here for usage: https://weaviate.io/developers/weaviate/client-libraries/python warnings.warn(`

Diese Nachricht ist ein Warnbanner und kann ignoriert werden. Weitere Informationen finden Sie hier Artikel im Weaviate-Blog.

Gliederung der Python-Schritte :

1. Installieren Sie die weaviate-client-Bibliothek
2. Clientinitialisierung
3. Schemaerstellung
4. Dateneinfügung
5. Initiierung der Sicherung
6. Datenwiederherstellung

1. Installation der Weaviate-Client-Bibliothek

 !pip install weaviate-client

2. Importieren von Schemaklassen für Artikel und Autor

In diesem Abschnitt werden die Datenstruktur und das Schema für die Klassen „Artikel“ und „Autor“ vorgestellt und die Grundlage für die Organisation der Daten gelegt. Es wird gezeigt, wie das Schema in Weaviate programmgesteuert definiert und verwaltet wird. Dabei wird die Flexibilität und Leistungsfähigkeit von Weaviate bei der Anpassung an verschiedene Datenmodelle aufgezeigt, die auf spezifische Anwendungsanforderungen zugeschnitten sind.

 import weaviate client = weaviate.Client("http://localhost:8080") # Schema classes to be created schema = { "classes": [ { "class": "Article", "description": "A class to store articles", "properties": [ {"name": "title", "dataType": ["string"], "description": "The title of the article"}, {"name": "content", "dataType": ["text"], "description": "The content of the article"}, {"name": "datePublished", "dataType": ["date"], "description": "The date the article was published"}, {"name": "url", "dataType": ["string"], "description": "The URL of the article"}, {"name": "customEmbeddings", "dataType": ["number[]"], "description": "Custom vector embeddings of the article"} ] }, { "class": "Author", "description": "A class to store authors", "properties": [ {"name": "name", "dataType": ["string"], "description": "The name of the author"}, {"name": "articles", "dataType": ["Article"], "description": "The articles written by the author"} ] } ] } client.schema.delete_class('Article') client.schema.delete_class('Author') client.schema.create(schema)

Python: Schemaklassen erstellen

3. Einrichten von Schema und Daten

Nach der Definition des Schemas führt das Notebook durch die Initialisierung des Weaviate-Clients, die Erstellung des Schemas in der Weaviate-Instanz und die Indizierung der Daten. Dieser Prozess füllt die Datenbank mit ersten Datensätzen und ermöglicht die Erkundung der Vektorsuchfunktionen von Weaviate. Es veranschaulicht die praktischen Schritte, die erforderlich sind, um Weaviate zum Speichern und Abfragen von Daten in einem vektorisierten Format zu nutzen.

 # JSON data to be Ingested data = [ { "class": "Article", "properties": { "title": "LangChain: OpenAI + S3 Loader", "content": "This article discusses the integration of LangChain with OpenAI and S3 Loader...", "url": "https://blog.min.io/langchain-openai-s3-loader/", "customEmbeddings": [0.4, 0.3, 0.2, 0.1] } }, { "class": "Article", "properties": { "title": "MinIO Webhook Event Notifications", "content": "Exploring the webhook event notification system in MinIO...", "url": "https://blog.min.io/minio-webhook-event-notifications/", "customEmbeddings": [0.1, 0.2, 0.3, 0.4] } }, { "class": "Article", "properties": { "title": "MinIO Postgres Event Notifications", "content": "An in-depth look at Postgres event notifications in MinIO...", "url": "https://blog.min.io/minio-postgres-event-notifications/", "customEmbeddings": [0.3, 0.4, 0.1, 0.2] } }, { "class": "Article", "properties": { "title": "From Docker to Localhost", "content": "A guide on transitioning from Docker to localhost environments...", "url": "https://blog.min.io/from-docker-to-localhost/", "customEmbeddings": [0.4, 0.1, 0.2, 0.3] } } ] for item in data: client.data_object.create( data_object=item["properties"], class_name=item["class"] )

Python: Daten nach Klasse indizieren

4. Erstellen eines Backups

Wenn die Daten indexiert sind, liegt der Fokus auf der Erhaltung des Zustands der Datenbank durch Backups. Dieser Teil des Notebooks zeigt, wie ein Backup-Vorgang in MinIO ausgelöst wird.

 result = client.backup.create( backup_id="backup-id", backend="s3", include_classes=["Article", "Author"], # specify classes to include or omit this for all classes wait_for_completion=True, ) print(result)

Python: Backup erstellen

Erwarten:

 {'backend': 's3', 'classes': ['Article', 'Author'], 'id': 'backup-id-2', 'path': 's3://weaviate-backups/backup-id-2', 'status': 'SUCCESS'}

Erfolgreiche Backup-Antwort

5. Löschen von Schemaklassen zu Wiederherstellungszwecken

Bevor Sie mit einer Wiederherstellung fortfahren, ist es manchmal notwendig, das vorhandene Schema zu löschen. Dieser Abschnitt zeigt die Schritte für einen sauberen Wiederherstellungsprozess. Dadurch wird sichergestellt, dass die wiederhergestellten Daten nicht mit vorhandenen Schemata oder Daten in der Datenbank in Konflikt geraten.

 client.schema.delete_class("Article") client.schema.delete_class("Author")

6. Wiederherstellen des Backups

In diesem Abschnitt wird erläutert, wie Sie die zuvor gesicherten Daten wiederherstellen und die Datenbank wieder in einen bekanntermaßen guten Zustand versetzen.

 result = client.backup.restore( backup_id="backup-id", backend="s3", wait_for_completion=True, ) print(result)

Python: Sicherung wiederherstellen

Erwarten:

 {'backend': 's3', 'classes': ['Article', 'Author'], 'id': 'backup-id', 'path': 's3://weaviate-backups/backup-id', 'status': 'SUCCESS'}

Erfolgreiche Backup-S3-Antwort

Fehlerbehandlung bei der Wiederherstellung

Dieser Teil des Notebooks enthält ein Beispiel für die Implementierung der Fehlerbehandlung während des Sicherungswiederherstellungsprozesses. Es bietet Einblicke in unerwartete Probleme bei Datenwiederherstellungsvorgängen.

 from weaviate.exceptions import BackupFailedError try: result = client.backup.restore( backup_id="backup-id", backend="s3", wait_for_completion=True, ) print("Backup restored successfully:", result) except BackupFailedError as e: print("Backup restore failed with error:", e) # Here you can add logic to handle the failure, such as retrying the operation or logging the error.

Erwarten:

 Backup restored successfully: {'backend': 's3', 'classes': ['Author', 'Article'], 'id': 'backup-id', 'path': 's3://weaviate-backups/backup-id', 'status': 'SUCCESS'}

Erfolgreiche Backup-Wiederherstellung

Überprüfen des Erfolgs der Wiederherstellung

Um abschließend zu bestätigen, dass der Sicherungs- und Wiederherstellungsprozess erfolgreich abgeschlossen wurde, enthält das Notebook einen Schritt zum Abrufen des Schemas der Klasse „Artikel“. Diese Überprüfung stellt sicher, dass die Daten und das Schema korrekt wiederhergestellt werden.

 client.schema.get("Article")

Gibt die Artikelklasse als JSON-Objekt zurück

Erwarten:

 {'class': 'Article', 'description': 'A class to store articles'... [Truncated]...}

Jeder Abschnitt des Notebooks bietet eine umfassende Anleitung durch den Lebenszyklus der Datenverwaltung in Weaviate, von der Ersteinrichtung und Datenauffüllung bis hin zu Sicherung, Wiederherstellung und Überprüfung. Alles wird innerhalb des Python-Ökosystems mithilfe der Weaviate-Client-Bibliothek durchgeführt.

Skizzieren des Prozesses mit curl

Bisher haben wir Ihnen gezeigt, wie Sie dies mit Python tun können. Wir dachten, es wäre hilfreich, intern über CURL zu zeigen, wie dieselben Vorgänge ohne das Schreiben eines Skripts durchgeführt werden können.

Um mit einer Weaviate-Instanz für Aufgaben wie das Erstellen eines Schemas, das Indizieren von Daten, das Durchführen von Backups und das Wiederherstellen von Daten zu interagieren, können bestimmte Curl-Befehle verwendet werden. Diese Befehle senden HTTP-Anfragen an die REST-API von Weaviate. Um beispielsweise ein Schema zu erstellen, wird eine POST-Anfrage mit den Schemadetails an den Schema-Endpunkt von Weaviate gesendet. Um Daten zu indizieren, wird eine POST-Anfrage mit der Datennutzlast an den Objekt-Endpunkt gesendet.

Backups werden durch eine POST-Anfrage an den Backup-Endpunkt ausgelöst und die Wiederherstellung erfolgt über eine POST-Anfrage an den Wiederherstellungs-Endpunkt. Jeder dieser Vorgänge erfordert die entsprechende JSON-Nutzlast, die normalerweise als Dateiverweis im Curl-Befehl mithilfe des @ -Symbols bereitgestellt wird.

Um Weaviate zu implementieren, benötigen wir natürlich Beispieldaten, mit denen wir arbeiten können.

Ich habe Folgendes beigefügt:

1. schema.json umreißt die Struktur der Daten, die wir indizieren möchten.

2. In data.json kommen unsere eigentlichen Daten ins Spiel, ihre Struktur richtet sich nach den Klassen in der Datei schema.json.

   
   

Die Dateien schema.json und data.json sind im MinIO Blog-Assets- Repository verfügbar. Hier .

schema.json

 { "classes": [ { "class": "Article", "description": "A class to store articles", "properties": [ {"name": "title", "dataType": ["string"], "description": "The title of the article"}, {"name": "content", "dataType": ["text"], "description": "The content of the article"}, {"name": "datePublished", "dataType": ["date"], "description": "The date the article was published"}, {"name": "url", "dataType": ["string"], "description": "The URL of the article"}, {"name": "customEmbeddings", "dataType": ["number[]"], "description": "Custom vector embeddings of the article"} ] }, { "class": "Author", "description": "A class to store authors", "properties": [ {"name": "name", "dataType": ["string"], "description": "The name of the author"}, {"name": "articles", "dataType": ["Article"], "description": "The articles written by the author"} ] } ] }

Beispielschemaklassen für „Artikel“ und „Autor“

Der schema.json Die Datei beschreibt die Struktur der zu indizierenden Daten und beschreibt detailliert die Klassen, Eigenschaften und ihre Datentypen. Damit wird die Grundlage dafür geschaffen, wie Daten in Weaviate organisiert und mit ihnen interagiert werden. Dieses Schema dient der KI als Blaupause, um die eingehenden Daten zu verstehen und zu kategorisieren und stellt sicher, dass die Vektorsuchmaschine präzise und relevant arbeiten kann.

Auf der anderen Seite Daten.json Datei füllt dieses Schema mit tatsächlichen Dateninstanzen und spiegelt reale Anwendungen und Szenarien wider. Diese Beispieldaten verdeutlichen das Potenzial der Suchfunktionen von Weaviate und bieten eine praktische Erfahrung, die zeigt, wie Abfragen gelöst und Ergebnisse dynamisch basierend auf dem Verständnis des Inhalts durch die KI generiert werden.

Daten.json

 [ { "class": "Article", "properties": { "title": "LangChain: OpenAI + S3 Loader", "content": "This article discusses the integration of LangChain with OpenAI and S3 Loader...", "url": "https://blog.min.io/langchain-openai-s3-loader/", "customEmbeddings": [0.4, 0.3, 0.2, 0.1] } }, { "class": "Article", "properties": { "title": "MinIO Webhook Event Notifications", "content": "Exploring the webhook event notification system in MinIO...", "url": "https://blog.min.io/minio-webhook-event-notifications/", "customEmbeddings": [0.1, 0.2, 0.3, 0.4] } }, { "class": "Article", "properties": { "title": "MinIO Postgres Event Notifications", "content": "An in-depth look at Postgres event notifications in MinIO...", "url": "https://blog.min.io/minio-postgres-event-notifications/", "customEmbeddings": [0.3, 0.4, 0.1, 0.2] } }, { "class": "Article", "properties": { "title": "From Docker to Localhost", "content": "A guide on transitioning from Docker to localhost environments...", "url": "https://blog.min.io/from-docker-to-localhost/", "customEmbeddings": [0.4, 0.1, 0.2, 0.3] } } ]

Beispieldaten mit Artikeln

Einrichten mit curl

Das Schema fungiert als strukturelles Rückgrat unseres Datenverwaltungssystems und definiert, wie Daten organisiert, indiziert und abgefragt werden.

Erstellen eines Weaviate-Schemas

Über einen einfachen Curl-Befehl und mit unseren lokal in unser aktuelles Arbeitsverzeichnis geklonten Beispieldateien können wir unsere schema.json direkt in Weaviate veröffentlichen und dabei die Regeln und Beziehungen festlegen, die für unsere Daten gelten.

 curl -X POST -H "Content-Type: application/json" \ --data @schema.json http://localhost:8080/v1/schema

CURL: erstellen

Auffüllen des Schemas: Indizieren von Daten

Nachdem unser Schema eingerichtet ist, besteht der nächste Schritt darin, es mit tatsächlichen Daten zu füllen. Mit einem weiteren Curl-Befehl indizieren wir unsere data.json im Schema.

 curl -X POST -H "Content-Type: application/json" \ --data @data.json http://localhost:8080/v1/objects

CURL: Index

Sicherstellung der Datenhaltbarkeit: Sichern mit MinIO

Wir müssen eine eindeutige Kennung oder „Backup-ID“ zuweisen. Diese Kennung erleichtert nicht nur die genaue Verfolgung und den Abruf von Backup-Sets, sondern stellt auch sicher, dass jeder Datensatz einer Versionskontrolle unterliegt.

 curl -X POST 'http://localhost:8080/v1/backups/s3' -H 'Content-Type:application/json' -d '{ "id": "backup-id", "include": [ "Article", "Author" ] }'

CURL: Backup-s3

Erwarten:

 {'backend': 's3', 'classes': ['Article', 'Author'], 'id': 'backup-id', 'path': 's3://weaviate-backups/backup-id', 'status': 'SUCCESS'}

Erfolgreiche Backup-S3-Antwort

Diese Ausgabe ist als JSON-Objekt formatiert. Sie enthält das verwendete Backend (in diesem Fall 's3' ), eine Liste der Klassen, die in das Backup einbezogen wurden ( 'Article' , 'Author' ), die dem Backup zugewiesene eindeutige ID ( 'backup-id' ), den Pfad, der angibt, wo das Backup im S3-Bucket gespeichert ist ( s3://weaviate-backups/backup-id ), und den Status des Vorgangs ( 'SUCCESS' ).

Diese strukturierte Antwort bestätigt nicht nur den erfolgreichen Abschluss des Sicherungsvorgangs, sondern bietet auch wichtige Informationen, die für zukünftige Referenz-, Prüf- oder Wiederherstellungsprozesse verwendet werden können.

Datenwiederherstellungsprozess

Die Wiederherstellung von Daten innerhalb des Weaviate-Ökosystems wird durch einen strukturierten API-Aufruf über eine POST-Anfrage erleichtert, die auf den durch die Backup-ID identifizierten Endpunkt /v1/backups/s3/backup-id/restore abzielt. Dieser Curl-Aufruf stellt nicht nur die verlorenen oder archivierten Daten wieder her, sondern ermöglicht Ihnen auch die Aufrechterhaltung der Kontinuität.

 curl -X POST 'http://localhost:8080/v1/backups/s3/backup-id/restore' \ -H 'Content-Type:application/json' \ -d '{ "id": "backup-id", "exclude": ["Author"] }'

CURL: wiederherstellen

Erwarten:

 { "backend": "s3", "classes": ["Article"], "id": "backup-id", "path": "s3://weaviate-backups/backup-id", "status": "SUCCESS" }

Erfolgreiche Wiederherstellungsantwort

Jeder dieser Befehle sollte basierend auf Ihrem spezifischen Setup und Ihren Anforderungen angepasst werden. Möglicherweise müssen Sie Endpunkt-URLs, Datendateipfade und andere Parameter nach Bedarf ändern. Stellen Sie außerdem sicher, dass die erforderlichen Dateien (schema.json, data.json) und Konfigurationen in Ihrer Umgebung verfügbar sind.

Zusätzliche Hinweise zu Weaviate

Automatisierungen mit GitOps

Durch die Kodifizierung aller Vorgänge in Git können Teams Änderungen problemlos verfolgen, zu vorherigen Zuständen zurückkehren und Konsistenz zwischen Umgebungen sicherstellen. GitOps-Workflows können mit Tools für kontinuierliche Integration/kontinuierliche Bereitstellung (CI/CD) und Kubernetes integriert werden, was die Orchestrierung von Containeranwendungen und die Infrastrukturverwaltung weiter vereinfacht. In einem zukünftigen Beitrag werden wir ausführlich auf die Automatisierung mit GitOps eingehen.

Teilsicherungen und -wiederherstellungen

Weaviate ermöglicht das Sichern oder Wiederherstellen bestimmter Klassen, was in Fällen wie der teilweisen Datenmigration oder Entwicklungstests nützlich ist.

Multi-Node-Backups: Stellen Sie bei Multi-Node-Setups, insbesondere in Kubernetes-Umgebungen, sicher, dass Ihre Konfiguration das Backup-Modul (wie Backup-S3 für MinIO) und die zugehörigen Umgebungsvariablen korrekt angibt.

Fehlerbehebung

Wenn beim Sichern oder Wiederherstellen Probleme auftreten, überprüfen Sie die Konfiguration Ihrer Umgebungsvariablen, insbesondere in Bezug auf die SSL-Einstellungen für S3-kompatiblen Speicher wie MinIO. Das Deaktivieren von SSL ( BACKUP_S3_USE_SSL: false ) kann bestimmte Verbindungsprobleme beheben.

Eine robuste und skalierbare Backup-Lösung für Weaviate mit MinIO

Am Ende dieser Untersuchung zur Integration von Weaviate mit MinIO mithilfe von Docker Compose wird deutlich, dass diese Kombination nicht nur eine technische Lösung, sondern eine strategische Verbesserung des Datenmanagements ist. Diese Integration passt perfekt zu MinIOs Engagement, skalierbare, sichere und leistungsstarke Datenspeicherlösungen bereitzustellen, die jetzt durch die KI-gesteuerten Funktionen von Weaviate noch verstärkt werden. Die Verwendung von Docker Compose vereinfacht diese Integration weiter und unterstreicht unseren Fokus darauf, komplexe Technologien zugänglich und handhabbar zu machen.

Wie immer ist das MinIO-Team bestrebt, Innovationen im Bereich Datenmanagement voranzutreiben. Unser Engagement für die Verbesserung und Optimierung der Datenspeicherung, des Datenzugriffs und der Datenanalyse steht im Mittelpunkt unserer Mission.

Durch die Kombination der erweiterten Vektordatenbankfunktionen von Weaviate mit den robusten Speicherlösungen von MinIO können Benutzer das volle Potenzial ihrer Daten ausschöpfen. Dazu gehört die Nutzung semantischer Suchfunktionen, die nicht nur die Zugänglichkeit der Daten, sondern auch deren Sicherheit auf grundlegender Ebene gewährleisten.

Wir sind wirklich inspiriert von der bemerkenswerten Innovation, die den Köpfen engagierter und leidenschaftlicher Entwickler wie Ihnen entspringt. Es begeistert uns, unsere Unterstützung anzubieten und Teil Ihrer Reise zur Erforschung fortschrittlicher Lösungen und zum Erreichen neuer Höhen in Ihren datengesteuerten Projekten zu sein. Bitte zögern Sie nicht, uns zu kontaktieren unter Locker , egal ob Sie Fragen haben oder einfach nur Hallo sagen möchten.