Dieser Beitrag wurde gemeinsam mit Justin Miles, Liv d'Aliberti und Joe Kovba von Leidos verfasst. 

Leidos ist ein Fortune-500-Führer für Wissenschafts- und Technologielösungen, der sich mit der Bewältigung einiger der weltweit größten Herausforderungen in den Bereichen Verteidigung, Geheimdienste, Innere Sicherheit, Zivilwesen und Gesundheitswesen befasst. In diesem Beitrag diskutieren wir, wie Leidos mit AWS zusammengearbeitet hat, um einen Ansatz zur datenschutzschonenden Inferenz mit großen Sprachmodellen (LLM) zu entwickeln AWS Nitro-Enklaven.

LLMs sind darauf ausgelegt, menschenähnliche Sprache zu verstehen und zu erzeugen und werden in vielen Branchen eingesetzt, darunter in der Regierung, im Gesundheitswesen, im Finanzwesen und im Bereich des geistigen Eigentums. LLMs haben eine breite Anwendbarkeit, einschließlich Chatbots, Inhaltsgenerierung, Sprachübersetzung, Stimmungsanalyse, Frage-Antwort-Systeme, Suchmaschinen und Codegenerierung. Die Einführung von LLM-basierter Inferenz in ein System birgt auch das Potenzial, Datenschutzbedrohungen mit sich zu bringen, einschließlich Modellexfiltration, Datenschutzverletzungen und unbeabsichtigter Manipulation von LLM-basierten Diensten. Es müssen technische Architekturen implementiert werden, um sicherzustellen, dass LLMs während der Inferenz keine sensiblen Informationen preisgeben.

In diesem Beitrag wird erläutert, wie Nitro Enclaves dazu beitragen kann, LLM-Modellbereitstellungen zu schützen, insbesondere solche, die personenbezogene Daten (PII) oder geschützte Gesundheitsinformationen (PHI) verwenden. Dieser Beitrag dient nur zu Bildungszwecken und sollte nicht in Produktionsumgebungen ohne zusätzliche Kontrollen verwendet werden.

Übersicht über LLMs und Nitro-Enklaven

Ein möglicher Anwendungsfall ist ein LLM-basierter Chatbot für sensible Abfragen, der einen Frage- und Antwortdienst mit PII und PHI ausführen soll. Die meisten aktuellen LLM-Chatbot-Lösungen weisen Benutzer ausdrücklich darauf hin, dass sie aus Sicherheitsgründen bei der Eingabe von Fragen keine personenbezogenen Daten oder personenbezogenen Daten angeben sollten. Um diese Bedenken auszuräumen und Kundendaten zu schützen, verlassen sich Serviceeigentümer in erster Linie auf Benutzerschutzmaßnahmen wie die folgenden:

• Schwärzung – Der Prozess der Identifizierung und Verschleierung sensibler Informationen wie PII in Dokumenten, Texten oder anderen Inhaltsformen. Dies kann mit Eingabedaten erreicht werden, bevor sie an ein Modell oder einen LLM gesendet werden, der darauf trainiert ist, seine Antworten automatisch zu redigieren.
• Multi-Faktor-Authentifizierung – Ein Sicherheitsprozess, bei dem Benutzer mehrere Authentifizierungsmethoden bereitstellen müssen, um ihre Identität zu überprüfen und Zugriff auf das LLM zu erhalten.
• Transport Layer Security (TLS) – Ein kryptografisches Protokoll, das eine sichere Kommunikation ermöglicht und den Datenschutz bei der Übertragung zwischen Benutzern und dem LLM-Dienst verbessert.

Obwohl diese Praktiken die Sicherheitslage des Dienstes verbessern, reichen sie nicht aus, um alle sensiblen Benutzerinformationen und andere sensible Informationen zu schützen, die ohne Wissen des Benutzers bestehen bleiben können.

In unserem Beispielanwendungsfall ist ein LLM-Service darauf ausgelegt, Fragen von Mitarbeitern zu Gesundheitsleistungen zu beantworten oder einen persönlichen Ruhestandsplan bereitzustellen. Lassen Sie uns die folgende Beispielarchitektur analysieren und Risikobereiche für den Datenschutz identifizieren.

Abbildung 1 – Diagramm der Datenschutzrisikobereiche

Die potenziellen Risikobereiche sind wie folgt:

1. Privilegierte Benutzer haben Zugriff auf die Instanz, die den Server beherbergt. Unbeabsichtigte oder unbefugte Änderungen am Dienst könnten dazu führen, dass sensible Daten auf unbeabsichtigte Weise offengelegt werden.
2. Benutzer müssen darauf vertrauen, dass der Dienst keine vertraulichen Informationen in Anwendungsprotokollen preisgibt oder speichert.
3. Änderungen an Anwendungspaketen können zu Änderungen am Dienst führen und zur Offenlegung sensibler Daten führen.
4. Privilegierte Benutzer mit Zugriff auf die Instanz haben uneingeschränkten Zugriff auf das vom Dienst verwendete LLM. Änderungen können dazu führen, dass falsche oder ungenaue Informationen an Benutzer zurückgegeben werden.

Nitro Enclaves bietet zusätzliche Isolation für Sie Amazon Elastic Compute-Cloud (Amazon EC2)-Instanz, die die verwendeten Daten vor unbefugtem Zugriff schützt, einschließlich Benutzern auf Administratorebene. In der vorherigen Architektur ist es möglich, dass eine unbeabsichtigte Änderung dazu führt, dass vertrauliche Daten im Klartext verbleiben und versehentlich einem Benutzer offengelegt werden, der möglicherweise keinen Zugriff auf diese Daten benötigt. Mit Nitro Enclaves erstellen Sie eine isolierte Umgebung aus Ihrer EC2-Instanz und können der Enklave CPU- und Speicherressourcen zuweisen. Diese Enklave ist eine äußerst restriktive virtuelle Maschine. Durch die Ausführung von Code, der vertrauliche Daten innerhalb der Enklave verarbeitet, kann keiner der übergeordneten Prozesse Enklavendaten anzeigen.

Nitro Enclaves bietet folgende Vorteile:

• Speicher- und CPU-Isolierung – Es basiert auf dem Nitro-Hypervisor, um die CPU und den Speicher der Enklave von Benutzern, Anwendungen und Bibliotheken auf der übergeordneten Instanz zu isolieren. Diese Funktion trägt dazu bei, die Enklave und Ihre Software zu isolieren und die Angriffsfläche für unbeabsichtigte Ereignisse erheblich zu reduzieren.
• Separate virtuelle Maschine – Enklaven sind separate virtuelle Maschinen, die an eine EC2-Instanz angeschlossen sind, um hochsensible Daten weiter zu schützen und sicher zu verarbeiten.
• Kein interaktiver Zugang – Enklaven bieten nur sichere lokale Socket-Konnektivität mit ihrer übergeordneten Instanz. Sie verfügen über keinen dauerhaften Speicher, keinen interaktiven Zugriff oder keine externe Vernetzung.
• Kryptografische Bescheinigung – Angebote von Nitro Enclaves kryptografische Bescheinigung, ein Prozess, der verwendet wird, um die Identität einer Enklave nachzuweisen und sicherzustellen, dass in Ihrer Enklave nur autorisierter Code ausgeführt wird.
• AWS-Integration – Nitro Enclaves ist integriert mit AWS-Schlüsselverwaltungsservice (AWS KMS), mit dem Sie Dateien entschlüsseln können, die mit AWS KMS innerhalb der Enklave verschlüsselt wurden. AWS-Zertifikatsmanager (ACM) für Nitro Enclaves ermöglicht Ihnen die Verwendung öffentlicher und privater SSL/TLS-Zertifikate mit Ihren Webanwendungen und Servern, die auf EC2-Instanzen mit Nitro Enclaves ausgeführt werden.

Sie können diese von Nitro Enclaves bereitgestellten Funktionen nutzen, um die mit PII- und PHI-Daten verbundenen Risiken zu mindern. Wir empfehlen, Nitro Enclaves in einen LLM-Dienst einzubinden, wenn vertrauliche Benutzerdaten verarbeitet werden.

Lösungsüberblick

Lassen Sie uns die Architektur des Beispieldienstes untersuchen, jetzt einschließlich Nitro Enclaves. Durch die Integration von Nitro Enclaves, wie in der folgenden Abbildung dargestellt, wird der LLM zu einem sichereren Chatbot für den Umgang mit PHI- oder PII-Daten.

Abbildung 2 – Lösungsübersichtsdiagramm

Benutzerdaten, einschließlich PII, PHI und Fragen, bleiben während des gesamten Anfrage-Antwort-Prozesses verschlüsselt, wenn die Anwendung in einer Enklave gehostet wird. Die während der Inferenz ausgeführten Schritte sind wie folgt:

1. Die Chatbot-App generiert temporäre AWS-Anmeldeinformationen und fordert den Benutzer auf, eine Frage einzugeben. Die Frage, die PII oder PHI enthalten kann, wird dann über AWS KMS verschlüsselt. Die verschlüsselte Benutzereingabe wird mit den temporären Anmeldeinformationen kombiniert, um die verschlüsselte Anfrage zu erstellen.
2. Die verschlüsselten Daten werden als POST-Anfrage an einen von Flask gehosteten HTTP-Server gesendet. Bevor sensible Daten akzeptiert werden, sollte dieser Endpunkt für HTTPs konfiguriert werden.
3. Die Client-App empfängt die POST-Anfrage und leitet sie über einen sicheren lokalen Kanal (z. B. vsock) an die Server-App weiter, die in Nitro Enclaves ausgeführt wird.
4. Die Nitro Enclaves-Server-App verwendet die temporären Anmeldeinformationen, um die Anfrage zu entschlüsseln, fragt das LLM ab und generiert die Antwort. Die modellspezifischen Einstellungen werden innerhalb der Enklaven gespeichert und durch kryptografische Bescheinigung geschützt.
5. Die Server-App verwendet dieselben temporären Anmeldeinformationen, um die Antwort zu verschlüsseln.
6. Die verschlüsselte Antwort wird über die Client-App als Antwort auf die POST-Anfrage an die Chatbot-App zurückgegeben.
7. Die Chatbot-App entschlüsselt die Antwort mithilfe ihres KMS-Schlüssels und zeigt dem Benutzer den Klartext an.

Voraussetzungen:

Bevor wir beginnen, benötigen Sie die folgenden Voraussetzungen, um die Lösung bereitzustellen:

Konfigurieren Sie eine EC2-Instanz

Führen Sie die folgenden Schritte aus, um eine EC2-Instanz zu konfigurieren:

1. Starten Sie eine r5.8xgroß EC2-Instanz mit der amzn2-ami-kernel-5.10-hvm-2.0.20230628.0-x86_64-gp2 AMI mit aktivierten Nitro-Enklaven.
2. Installieren Sie die Nitro Enclaves-CLI, um Nitro Enclaves-Anwendungen zu erstellen und auszuführen:
   • sudo amazon-linux-extras install aws-nitro-enclaves-cli -y
   • sudo yum install aws-nitro-enclaves-cli-devel -y
3. Überprüfen Sie die Installation der Nitro Enclaves CLI:
   • nitro-cli –version
   • Die in diesem Beitrag verwendete Version ist 1.2.2
4. Installieren Sie Git und Docker, um Docker-Images zu erstellen und laden Sie die Anwendung von GitHub herunter. Fügen Sie Ihren Instanzbenutzer zur Docker-Gruppe hinzu ( ist Ihr IAM-Instanzbenutzer):
   • sudo yum install git -y
   • sudo usermod -aG ne <USER>
   • sudo usermod -aG docker <USER>
   • sudo systemctl start docker && sudo systemctl enable docker
5. Starten und aktivieren Sie die Nitro Enclaves Allocator- und Vsock-Proxy-Dienste:
   • sudo systemctl start nitro-enclaves-allocator.service && sudo systemctl enable nitro-enclaves-allocator.service
   • sudo systemctl start nitro-enclaves-vsock-proxy.service && sudo systemctl enable nitro-enclaves-vsock-proxy.service

Nitro Enclaves verwendet eine lokale Socket-Verbindung namens vsock, um einen sicheren Kanal zwischen der übergeordneten Instanz und der Enklave zu erstellen.

Nachdem alle Dienste gestartet und aktiviert wurden, starten Sie die Instanz neu, um zu überprüfen, ob alle Benutzergruppen und Dienste ordnungsgemäß ausgeführt werden:

sudo shutdown -r now

Konfigurieren Sie den Nitro Enclaves-Zuweisungsdienst

Nitro Enclaves ist eine isolierte Umgebung, die einen Teil der Instanz-CPU und des Arbeitsspeichers für die Ausführung der Enklave bestimmt. Mit dem Nitro Enclaves-Zuweisungsdienst können Sie angeben, wie viele CPUs und wie viel Speicher von der übergeordneten Instanz zum Ausführen der Enklave übernommen werden.

Ändern Sie die reservierten Ressourcen der Enklave mit einem Texteditor (für unsere Lösung weisen wir 8 CPUs und 70,000 MiB Speicher zu, um genügend Ressourcen bereitzustellen):

vi /etc/nitro_enclaves/allocatory.yaml

Abbildung 3 – AWS Nitro Enclaves Allocator Service-Konfiguration

Klonen Sie das Projekt

Nachdem Sie die EC2-Instanz konfiguriert haben, können Sie den Code herunterladen, um den sensiblen Chatbot mit einem LLM innerhalb von Nitro Enclaves auszuführen.

Sie müssen das aktualisieren server.py Datei mit der entsprechenden KMS-Schlüssel-ID, die Sie zu Beginn erstellt haben, um die LLM-Antwort zu verschlüsseln.

1. Klonen Sie das GitHub-Projekt:
   • cd ~/ && git clone https://<THE_REPO.git>
2. Navigieren Sie zum Projektordner, um das zu erstellen enclave_base Docker-Image, das das enthält Nitro Enclaves Software-Entwicklungskit (SDK) für kryptografische Attestierungsdokumente aus dem Nitro Hypervisor (dieser Schritt kann bis zu 15 Minuten dauern):
   • cd /nitro_llm/enclave_base
   • docker build ./ -t “enclave_base”

Speichern Sie das LLM in der EC2-Instanz

Wir verwenden das Open-Source-LLM Bloom 560m für die Verarbeitung natürlicher Sprache, um Antworten zu generieren. Dieses Modell ist nicht auf PII und PHI abgestimmt, sondern zeigt, wie ein LLM innerhalb einer Enklave leben kann. Das Modell muss außerdem auf der übergeordneten Instanz gespeichert werden, damit es über das Dockerfile in die Enklave kopiert werden kann.

1. Navigieren Sie zum Projekt:
   • cd /nitro_llm
2. Installieren Sie die erforderlichen Voraussetzungen, um das Modell lokal zu speichern:
   • pip3 install requirements.txt
3. Führen Sie die save_model.py App, um das Modell innerhalb der zu speichern /nitro_llm/enclave/bloom Verzeichnis:
   • python3 save_model.py

Erstellen Sie das Nitro Enclaves-Image und führen Sie es aus

Um Nitro Enclaves auszuführen, müssen Sie eine Enclave-Image-Datei (EIF) aus einem Docker-Image Ihrer Anwendung erstellen. Die Docker-Datei im Enklave-Verzeichnis enthält die Dateien, den Code und das LLM, die innerhalb der Enklave ausgeführt werden.

Der Aufbau und Betrieb der Enklave wird mehrere Minuten dauern.

1. Navigieren Sie zum Stammverzeichnis des Projekts:
   • cd /nitro_llm
2. Erstellen Sie die Enclave-Image-Datei als enclave.eif:
   • nitro-cli build-enclave --docker-uri enclave:latest --output-file enclave.eif

Abbildung 4 – AWS Nitro Enclaves Build-Ergebnis

Beim Aufbau der Enklave werden eine Reihe eindeutiger Hashes und Plattformkonfigurationsregister (PCRs) erstellt. Bei den PCRs handelt es sich um eine zusammenhängende Messung zum Nachweis der Identität der Hardware und Anwendung. Diese PCRs werden für die kryptografische Bescheinigung benötigt und während des Aktualisierungsschritts der KMS-Schlüsselrichtlinie verwendet.

3. Führen Sie die Enklave mit den Ressourcen aus aus allocator.service (Hinzufügen der --attach-console Argument am Ende führt die Enklave im Debug-Modus aus):
   • nitro-cli run-enclave --cpu-count 8 --memory 70000 --enclave-cid 16 --eif-path enclave.eif

Sie müssen mindestens das Vierfache der EIF-Dateigröße zuweisen. Dies kann im geändert werden allocator.service aus den vorherigen Schritten.

4. Überprüfen Sie mit dem folgenden Befehl, ob die Enklave ausgeführt wird:
   • nitro-cli describe-enclaves

Abbildung 5 – AWS Nitro Enclave Describe-Befehl

Aktualisieren Sie die KMS-Schlüsselrichtlinie

Führen Sie die folgenden Schritte aus, um Ihre KMS-Schlüsselrichtlinie zu aktualisieren:

1. Wählen Sie in der AWS KMS-Konsole aus Vom Kunden verwaltete Schlüssel im Navigationsbereich.
2. Suchen Sie nach dem Schlüssel, den Sie als Voraussetzung generiert haben.
3. Auswählen Bearbeiten über die Schlüsselpolitik.
4. Aktualisieren Sie die Schlüsselrichtlinie mit den folgenden Informationen:
   • Ihre Konto-ID
   • Ihr IAM-Benutzername
   • Die aktualisierte Cloud9-Umgebungsinstanzrolle
   • Aktionen kms:Encrypt und kms:Decrypt
   • Enklavieren Sie PCRs (z. B. PCR0, PCR1, PCR2) mit einer Bedingungsanweisung in Ihre Schlüsselrichtlinie

Siehe den folgenden wichtigen Richtliniencode:

{
   "Version":"2012-10-17",
   "Id":"key-default-1",
   "Statement":[
      {
         "Sid":"Enable User permissions",
         "Effect":"Allow",
         "Principal":{
            "AWS":"arn:aws:iam:::user/"
         },
         "Action":[
            "kms:CreateAlias",
            "kms:CreateKey",
            "kms:DeleteAlias",
            "kms:Describe*",
            "kms:GenerateRandom",
            "kms:Get*",
            "kms:List*",
            "kms:TagResource",
            "kms:UntagResource",
            "iam:ListGroups",
            "iam:ListRoles",
            "iam:ListUsers"
         ],
         "Resource":"*"
      },
      {
         "Sid":"Enable Enclave permissions",
         "Effect":"Allow",
         "Principal":{
            "AWS":"arn:aws:iam:::role/"
         },
         "Action":[
            "kms:Encrypt",
            "kms:Decrypt"
         ],
         "Resource":"*",
         "Condition":{
            "StringEqualsIgnoreCase":{
               "kms:RecipientAttestation:PCR0":"",
               "kms:RecipientAttestation:PCR1":"",
               "kms:RecipientAttestation:PCR2":""
            }
         }
      }
   ]
}

Speichern Sie die Chatbot-App

Um eine vertrauliche Abfrage-Chatbot-Anwendung nachzuahmen, die außerhalb des AWS-Kontos läuft, müssen Sie die speichern chatbot.py App und führen Sie sie in der Cloud9-Umgebung aus. Ihre Cloud9-Umgebung verwendet ihre Instanzrolle für temporäre Anmeldeinformationen, um Berechtigungen vom EC2 zu trennen, auf dem die Enklave ausgeführt wird. Führen Sie die folgenden Schritte aus:

1. Öffnen Sie in der Cloud9-Konsole die von Ihnen erstellte Umgebung.
2. Kopieren Sie den folgenden Code in eine neue Datei wie chatbot.py in das Hauptverzeichnis.
3. Installieren Sie die erforderlichen Module:
   • pip install boto3
   • Pip install requests
4. Notieren Sie sich auf der Amazon EC2-Konsole die IP, die Ihrer Nitro Enclaves-Instanz zugeordnet ist.
5. Aktualisieren Sie die URL-Variable in http://<ec2instanceIP>:5001.

"""
Modules for a basic chatbot like application and AWS communications
"""
import base64
import requests
import boto3
 
def get_identity_document():
    """
    Get identity document for current EC2 Host
    """
    identity_doc = requests.get(
        "http://169.254.169.254/latest/dynamic/instance-identity/document", timeout=30)
    return identity_doc
 
def get_region(identity):
    """
    Get account of current instance identity
    """
    region = identity.json()["region"]
    return region
 
def get_account(identity):
    """
    Get account of current instance identity
    """
    account = identity.json()["accountId"]
    return account
 
def set_identity():
    """
    Set region and account for KMS
    """
    identity = get_identity_document()
    region = get_region(identity)
    account = get_account(identity)
    return region, account
 
def prepare_server_request(ciphertext):
    """
    Get the AWS credential from EC2 instance metadata
    """
    instance_prof = requests.get(
        "http://169.254.169.254/latest/meta-data/iam/security-credentials/", timeout=30)
    instance_profile_name = instance_prof.text
 
    instance_prof_json = requests.get(
        f"http://169.254.169.254/latest/meta-data/iam/security-credentials/{instance_profile_name}",
        timeout=30)
    response = instance_prof_json.json()
 
    credential = {
        'access_key_id': response['AccessKeyId'],
        'secret_access_key': response['SecretAccessKey'],
        'token': response['Token'],
        'region': REGION,
        'ciphertext': ciphertext
    }
    return credential
 
def get_user_input():
    """
    Start chatbot to collect user input
    """
    print("Chatbot: Hello! How can I assist you?")
    user_input = input('Your Question: ')
    return user_input.lower()
 
def encrypt_string(user_input, alias, kms):
    """
    Encrypt user input using AWS KMS
    """
    file_contents = user_input
    encrypted_file = kms.encrypt(KeyId=f'alias/{alias}', Plaintext=file_contents)
    encrypted_file_contents = encrypted_file[u'CiphertextBlob']
    encrypted_file_contents_base64 = base64.b64encode(encrypted_file_contents)
    return encrypted_file_contents_base64.decode()
 
def decrypt_data(encrypted_data, kms):
    """
    Decrypt the LLM response using AWS KMS
    """
    try:
        ciphertext_blob = base64.b64decode(encrypted_data)
        response = kms.decrypt(CiphertextBlob=ciphertext_blob)
        decrypted_data = response['Plaintext'].decode()
        return decrypted_data
    except ImportError as e_decrypt:
        print("Decryption failed:", e_decrypt)
        return None
 
REGION, ACCOUNT = set_identity()
  
def main():
    """
    Main function to encrypt/decrypt data and send/receive with parent instance
    """
    kms = boto3.client('kms', region_name=REGION)
    alias = "ncsnitro"
    user_input = get_user_input()
    encrypted_input = encrypt_string(user_input, alias, kms)
    server_request = prepare_server_request(encrypted_input)
    url = 'http://<EC2 Instance Private IP>:5001'
    x = requests.post(url, json = server_request)
    response_body = x.json()
    llm_response = decrypt_data(response_body["EncryptedData"], kms)
    print(llm_response)
 
if __name__ == '__main__':
    main()

6. Führen Sie die Chatbot-Anwendung aus:

• • python3 chat.py

Wenn es ausgeführt wird, fragt das Terminal nach der Benutzereingabe und folgt dem Architekturdiagramm von zuvor, um eine sichere Antwort zu generieren.

Führen Sie den privaten Frage- und Antwort-Chatbot aus

Da Nitro Enclaves nun auf der EC2-Instanz läuft, können Sie Ihrem Chatbot PHI- und PII-Fragen sicherer stellen. Schauen wir uns ein Beispiel an.

Innerhalb der Cloud9-Umgebung stellen wir unserem Chatbot eine Frage und geben unseren Benutzernamen an.

Abbildung 6 – Dem Chatbot eine Frage stellen

AWS KMS verschlüsselt die Frage, die wie im folgenden Screenshot aussieht.

Abbildung 7 – Verschlüsselte Frage

Anschließend wird es an die Enklave gesendet und beim gesicherten LLM abgefragt. Die Frage und Antwort des LLM sehen wie im folgenden Screenshot aus (das Ergebnis und die verschlüsselte Antwort sind innerhalb der Enklave nur im Debug-Modus sichtbar).

Abbildung 8 – Antwort von LLM

Das Ergebnis wird dann mit AWS KMS verschlüsselt und zur Entschlüsselung an die Cloud9-Umgebung zurückgegeben.

Abbildung 9 – Endgültige entschlüsselte Antwort

Aufräumen

Führen Sie die folgenden Schritte aus, um Ihre Ressourcen zu bereinigen:

1. Stoppen Sie die EC2-Instanz, die zur Unterbringung Ihrer Enklave erstellt wurde.
2. Löschen Sie die Cloud9-Umgebung.
3. Löschen Sie den KMS-Schlüssel.
4. Entfernen Sie die EC2-Instanzrolle und die IAM-Benutzerberechtigungen.

Zusammenfassung

In diesem Beitrag haben wir gezeigt, wie man Nitro Enclaves verwendet, um einen LLM-Frage- und Antwortdienst bereitzustellen, der PII- und PHI-Informationen sicherer sendet und empfängt. Dies wurde auf Amazon EC2 bereitgestellt und die Enklaven sind in AWS KMS integriert, wodurch der Zugriff auf einen KMS-Schlüssel eingeschränkt wird, sodass nur Nitro-Enklaven und der Endbenutzer den Schlüssel verwenden und die Frage entschlüsseln dürfen.

Wenn Sie planen, diese Architektur zu skalieren, um größere Arbeitslasten zu unterstützen, stellen Sie sicher, dass der Modellauswahlprozess Ihren Modellanforderungen mit EC2-Ressourcen entspricht. Darüber hinaus müssen Sie die maximale Anforderungsgröße berücksichtigen und welche Auswirkungen diese auf den HTTP-Server und die Inferenzzeit gegenüber dem Modell haben wird. Viele dieser Parameter können über die Modell- und HTTP-Servereinstellungen angepasst werden.

Der beste Weg, die spezifischen Einstellungen und Anforderungen für Ihre Arbeitslast zu ermitteln, ist das Testen mit einem fein abgestimmten LLM. Obwohl in diesem Beitrag nur die Verarbeitung sensibler Daten in natürlicher Sprache behandelt wurde, können Sie diese Architektur ändern, um alternative LLMs zu unterstützen, die Audio, Computer Vision oder Multimodalitäten unterstützen. Die gleichen hier hervorgehobenen Sicherheitsprinzipien können auf Daten in jedem Format angewendet werden. Die zum Erstellen dieses Beitrags verwendeten Ressourcen sind auf der verfügbar GitHub Repo.

Teilen Sie im Kommentarbereich mit, wie Sie diese Lösung an Ihre Umgebung anpassen werden.

Über die Autoren

Justin Miles ist Cloud-Ingenieur im Leidos Digital Modernization Sector im Office of Technology. In seiner Freizeit spielt er gerne Golf und reist.

Liv d'Aliberti ist Forscher im Leidos AI/ML Accelerator im Office of Technology. Ihre Forschung konzentriert sich auf maschinelles Lernen unter Wahrung der Privatsphäre.

Chris Renzo ist Senior Solution Architect innerhalb der AWS Defence and Aerospace-Organisation. Außerhalb der Arbeit genießt er den Ausgleich zwischen warmem Wetter und Reisen.

Joe Kovba ist Vizepräsident im Leidos Digital Modernization Sector. In seiner Freizeit leitet er gerne Fußballspiele und spielt Softball.

• SEO-gestützte Content- und PR-Distribution. Holen Sie sich noch heute Verstärkung.
• PlatoData.Network Vertikale generative KI. Motiviere dich selbst. Hier zugreifen.
• PlatoAiStream. Web3-Intelligenz. Wissen verstärkt. Hier zugreifen.
• PlatoESG. Kohlenstoff, CleanTech, Energie, Umwelt, Solar, Abfallwirtschaft. Hier zugreifen.
• PlatoHealth. Informationen zu Biotechnologie und klinischen Studien. Hier zugreifen.
• Quelle: https://aws.amazon.com/blogs/machine-learning/large-language-model-inference-over-confidential-data-using-aws-nitro-enclaves/